Add files using upload-large-folder tool

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/adapters/__init__.py

@@ -0,0 +1,8 @@
+"""**Adapters** are used to adapt LangChain models to other APIs.
+
+LangChain integrates with many model providers.
+While LangChain has its own message and model APIs,
+LangChain has also made it as easy as
+possible to explore other models by exposing an **adapter** to adapt LangChain
+models to the other APIs, as to the OpenAI API.
+"""

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/adapters/openai.py

@@ -0,0 +1,421 @@
+from __future__ import annotations
+
+import importlib
+from typing import (
+    Any,
+    AsyncIterator,
+    Dict,
+    Iterable,
+    List,
+    Mapping,
+    Sequence,
+    Union,
+    overload,
+)
+
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import (
+    AIMessage,
+    AIMessageChunk,
+    BaseMessage,
+    BaseMessageChunk,
+    ChatMessage,
+    FunctionMessage,
+    HumanMessage,
+    SystemMessage,
+    ToolMessage,
+)
+from pydantic import BaseModel
+from typing_extensions import Literal
+
+
+async def aenumerate(
+    iterable: AsyncIterator[Any], start: int = 0
+) -> AsyncIterator[tuple[int, Any]]:
+    """Async version of enumerate function."""
+    i = start
+    async for x in iterable:
+        yield i, x
+        i += 1
+
+
+class IndexableBaseModel(BaseModel):
+    """Allows a BaseModel to return its fields by string variable indexing."""
+
+    def __getitem__(self, item: str) -> Any:
+        return getattr(self, item)
+
+
+class Choice(IndexableBaseModel):
+    """Choice."""
+
+    message: dict
+
+
+class ChatCompletions(IndexableBaseModel):
+    """Chat completions."""
+
+    choices: List[Choice]
+
+
+class ChoiceChunk(IndexableBaseModel):
+    """Choice chunk."""
+
+    delta: dict
+
+
+class ChatCompletionChunk(IndexableBaseModel):
+    """Chat completion chunk."""
+
+    choices: List[ChoiceChunk]
+
+
+def convert_dict_to_message(_dict: Mapping[str, Any]) -> BaseMessage:
+    """Convert a dictionary to a LangChain message.
+
+    Args:
+        _dict: The dictionary.
+
+    Returns:
+        The LangChain message.
+    """
+    role = _dict.get("role")
+    if role == "user":
+        return HumanMessage(content=_dict.get("content", ""))
+    elif role == "assistant":
+        # Fix for azure
+        # Also OpenAI returns None for tool invocations
+        content = _dict.get("content", "") or ""
+        additional_kwargs: Dict = {}
+        if function_call := _dict.get("function_call"):
+            additional_kwargs["function_call"] = dict(function_call)
+        if tool_calls := _dict.get("tool_calls"):
+            additional_kwargs["tool_calls"] = tool_calls
+        if context := _dict.get("context"):
+            additional_kwargs["context"] = context
+        return AIMessage(content=content, additional_kwargs=additional_kwargs)
+    elif role == "system":
+        return SystemMessage(content=_dict.get("content", ""))
+    elif role == "function":
+        return FunctionMessage(content=_dict.get("content", ""), name=_dict.get("name"))  # type: ignore[arg-type]
+    elif role == "tool":
+        additional_kwargs = {}
+        if "name" in _dict:
+            additional_kwargs["name"] = _dict["name"]
+        return ToolMessage(
+            content=_dict.get("content", ""),
+            tool_call_id=_dict.get("tool_call_id"),
+            additional_kwargs=additional_kwargs,
+        )
+    else:
+        return ChatMessage(content=_dict.get("content", ""), role=role)  # type: ignore[arg-type]
+
+
+def convert_message_to_dict(message: BaseMessage) -> dict:
+    """Convert a LangChain message to a dictionary.
+
+    Args:
+        message: The LangChain message.
+
+    Returns:
+        The dictionary.
+    """
+    message_dict: Dict[str, Any]
+    if isinstance(message, ChatMessage):
+        message_dict = {"role": message.role, "content": message.content}
+    elif isinstance(message, HumanMessage):
+        message_dict = {"role": "user", "content": message.content}
+    elif isinstance(message, AIMessage):
+        message_dict = {"role": "assistant", "content": message.content}
+        if "function_call" in message.additional_kwargs:
+            message_dict["function_call"] = message.additional_kwargs["function_call"]
+            # If function call only, content is None not empty string
+            if message_dict["content"] == "":
+                message_dict["content"] = None
+        if "tool_calls" in message.additional_kwargs:
+            message_dict["tool_calls"] = message.additional_kwargs["tool_calls"]
+            # If tool calls only, content is None not empty string
+            if message_dict["content"] == "":
+                message_dict["content"] = None
+        if "context" in message.additional_kwargs:
+            message_dict["context"] = message.additional_kwargs["context"]
+            # If context only, content is None not empty string
+            if message_dict["content"] == "":
+                message_dict["content"] = None
+    elif isinstance(message, SystemMessage):
+        message_dict = {"role": "system", "content": message.content}
+    elif isinstance(message, FunctionMessage):
+        message_dict = {
+            "role": "function",
+            "content": message.content,
+            "name": message.name,
+        }
+    elif isinstance(message, ToolMessage):
+        message_dict = {
+            "role": "tool",
+            "content": message.content,
+            "tool_call_id": message.tool_call_id,
+        }
+    else:
+        raise TypeError(f"Got unknown type {message}")
+    if "name" in message.additional_kwargs:
+        message_dict["name"] = message.additional_kwargs["name"]
+    return message_dict
+
+
+def convert_openai_messages(messages: Sequence[Dict[str, Any]]) -> List[BaseMessage]:
+    """Convert dictionaries representing OpenAI messages to LangChain format.
+
+    Args:
+        messages: List of dictionaries representing OpenAI messages
+
+    Returns:
+        List of LangChain BaseMessage objects.
+    """
+    return [convert_dict_to_message(m) for m in messages]
+
+
+def _convert_message_chunk(chunk: BaseMessageChunk, i: int) -> dict:
+    _dict: Dict[str, Any] = {}
+    if isinstance(chunk, AIMessageChunk):
+        if i == 0:
+            # Only shows up in the first chunk
+            _dict["role"] = "assistant"
+        if "function_call" in chunk.additional_kwargs:
+            _dict["function_call"] = chunk.additional_kwargs["function_call"]
+            # If the first chunk is a function call, the content is not empty string,
+            # not missing, but None.
+            if i == 0:
+                _dict["content"] = None
+        if "tool_calls" in chunk.additional_kwargs:
+            _dict["tool_calls"] = chunk.additional_kwargs["tool_calls"]
+            # If the first chunk is tool calls, the content is not empty string,
+            # not missing, but None.
+            if i == 0:
+                _dict["content"] = None
+        else:
+            _dict["content"] = chunk.content
+    else:
+        raise ValueError(f"Got unexpected streaming chunk type: {type(chunk)}")
+    # This only happens at the end of streams, and OpenAI returns as empty dict
+    if _dict == {"content": ""}:
+        _dict = {}
+    return _dict
+
+
+def _convert_message_chunk_to_delta(chunk: BaseMessageChunk, i: int) -> Dict[str, Any]:
+    _dict = _convert_message_chunk(chunk, i)
+    return {"choices": [{"delta": _dict}]}
+
+
+class ChatCompletion:
+    """Chat completion."""
+
+    @overload
+    @staticmethod
+    def create(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[False] = False,
+        **kwargs: Any,
+    ) -> dict: ...
+
+    @overload
+    @staticmethod
+    def create(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[True],
+        **kwargs: Any,
+    ) -> Iterable: ...
+
+    @staticmethod
+    def create(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Union[dict, Iterable]:
+        models = importlib.import_module("langchain.chat_models")
+        model_cls = getattr(models, provider)
+        model_config = model_cls(**kwargs)
+        converted_messages = convert_openai_messages(messages)
+        if not stream:
+            result = model_config.invoke(converted_messages)
+            return {"choices": [{"message": convert_message_to_dict(result)}]}
+        else:
+            return (
+                _convert_message_chunk_to_delta(c, i)
+                for i, c in enumerate(model_config.stream(converted_messages))
+            )
+
+    @overload
+    @staticmethod
+    async def acreate(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[False] = False,
+        **kwargs: Any,
+    ) -> dict: ...
+
+    @overload
+    @staticmethod
+    async def acreate(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[True],
+        **kwargs: Any,
+    ) -> AsyncIterator: ...
+
+    @staticmethod
+    async def acreate(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Union[dict, AsyncIterator]:
+        models = importlib.import_module("langchain.chat_models")
+        model_cls = getattr(models, provider)
+        model_config = model_cls(**kwargs)
+        converted_messages = convert_openai_messages(messages)
+        if not stream:
+            result = await model_config.ainvoke(converted_messages)
+            return {"choices": [{"message": convert_message_to_dict(result)}]}
+        else:
+            return (
+                _convert_message_chunk_to_delta(c, i)
+                async for i, c in aenumerate(model_config.astream(converted_messages))
+            )
+
+
+def _has_assistant_message(session: ChatSession) -> bool:
+    """Check if chat session has an assistant message."""
+    return any([isinstance(m, AIMessage) for m in session["messages"]])
+
+
+def convert_messages_for_finetuning(
+    sessions: Iterable[ChatSession],
+) -> List[List[dict]]:
+    """Convert messages to a list of lists of dictionaries for fine-tuning.
+
+    Args:
+        sessions: The chat sessions.
+
+    Returns:
+        The list of lists of dictionaries.
+    """
+    return [
+        [convert_message_to_dict(s) for s in session["messages"]]
+        for session in sessions
+        if _has_assistant_message(session)
+    ]
+
+
+class Completions:
+    """Completions."""
+
+    @overload
+    @staticmethod
+    def create(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[False] = False,
+        **kwargs: Any,
+    ) -> ChatCompletions: ...
+
+    @overload
+    @staticmethod
+    def create(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[True],
+        **kwargs: Any,
+    ) -> Iterable: ...
+
+    @staticmethod
+    def create(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Union[ChatCompletions, Iterable]:
+        models = importlib.import_module("langchain.chat_models")
+        model_cls = getattr(models, provider)
+        model_config = model_cls(**kwargs)
+        converted_messages = convert_openai_messages(messages)
+        if not stream:
+            result = model_config.invoke(converted_messages)
+            return ChatCompletions(
+                choices=[Choice(message=convert_message_to_dict(result))]
+            )
+        else:
+            return (
+                ChatCompletionChunk(
+                    choices=[ChoiceChunk(delta=_convert_message_chunk(c, i))]
+                )
+                for i, c in enumerate(model_config.stream(converted_messages))
+            )
+
+    @overload
+    @staticmethod
+    async def acreate(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[False] = False,
+        **kwargs: Any,
+    ) -> ChatCompletions: ...
+
+    @overload
+    @staticmethod
+    async def acreate(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: Literal[True],
+        **kwargs: Any,
+    ) -> AsyncIterator: ...
+
+    @staticmethod
+    async def acreate(
+        messages: Sequence[Dict[str, Any]],
+        *,
+        provider: str = "ChatOpenAI",
+        stream: bool = False,
+        **kwargs: Any,
+    ) -> Union[ChatCompletions, AsyncIterator]:
+        models = importlib.import_module("langchain.chat_models")
+        model_cls = getattr(models, provider)
+        model_config = model_cls(**kwargs)
+        converted_messages = convert_openai_messages(messages)
+        if not stream:
+            result = await model_config.ainvoke(converted_messages)
+            return ChatCompletions(
+                choices=[Choice(message=convert_message_to_dict(result))]
+            )
+        else:
+            return (
+                ChatCompletionChunk(
+                    choices=[ChoiceChunk(delta=_convert_message_chunk(c, i))]
+                )
+                async for i, c in aenumerate(model_config.astream(converted_messages))
+            )
+
+
+class Chat:
+    """Chat."""
+
+    def __init__(self) -> None:
+        self.completions = Completions()
+
+
+chat = Chat()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/agent_toolkits/__init__.py

@@ -0,0 +1,170 @@
+"""**Toolkits** are sets of tools that can be used to interact with
+various services and APIs.
+"""
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.agent_toolkits.ainetwork.toolkit import (
+        AINetworkToolkit,
+    )
+    from langchain_community.agent_toolkits.amadeus.toolkit import (
+        AmadeusToolkit,
+    )
+    from langchain_community.agent_toolkits.azure_ai_services import (
+        AzureAiServicesToolkit,
+    )
+    from langchain_community.agent_toolkits.azure_cognitive_services import (
+        AzureCognitiveServicesToolkit,
+    )
+    from langchain_community.agent_toolkits.cassandra_database.toolkit import (
+        CassandraDatabaseToolkit,  # noqa: F401
+    )
+    from langchain_community.agent_toolkits.cogniswitch.toolkit import (
+        CogniswitchToolkit,
+    )
+    from langchain_community.agent_toolkits.connery import (
+        ConneryToolkit,
+    )
+    from langchain_community.agent_toolkits.file_management.toolkit import (
+        FileManagementToolkit,
+    )
+    from langchain_community.agent_toolkits.gmail.toolkit import (
+        GmailToolkit,
+    )
+    from langchain_community.agent_toolkits.jira.toolkit import (
+        JiraToolkit,
+    )
+    from langchain_community.agent_toolkits.json.base import (
+        create_json_agent,
+    )
+    from langchain_community.agent_toolkits.json.toolkit import (
+        JsonToolkit,
+    )
+    from langchain_community.agent_toolkits.multion.toolkit import (
+        MultionToolkit,
+    )
+    from langchain_community.agent_toolkits.nasa.toolkit import (
+        NasaToolkit,
+    )
+    from langchain_community.agent_toolkits.nla.toolkit import (
+        NLAToolkit,
+    )
+    from langchain_community.agent_toolkits.office365.toolkit import (
+        O365Toolkit,
+    )
+    from langchain_community.agent_toolkits.openapi.base import (
+        create_openapi_agent,
+    )
+    from langchain_community.agent_toolkits.openapi.toolkit import (
+        OpenAPIToolkit,
+    )
+    from langchain_community.agent_toolkits.playwright.toolkit import (
+        PlayWrightBrowserToolkit,
+    )
+    from langchain_community.agent_toolkits.polygon.toolkit import (
+        PolygonToolkit,
+    )
+    from langchain_community.agent_toolkits.powerbi.base import (
+        create_pbi_agent,
+    )
+    from langchain_community.agent_toolkits.powerbi.chat_base import (
+        create_pbi_chat_agent,
+    )
+    from langchain_community.agent_toolkits.powerbi.toolkit import (
+        PowerBIToolkit,
+    )
+    from langchain_community.agent_toolkits.slack.toolkit import (
+        SlackToolkit,
+    )
+    from langchain_community.agent_toolkits.spark_sql.base import (
+        create_spark_sql_agent,
+    )
+    from langchain_community.agent_toolkits.spark_sql.toolkit import (
+        SparkSQLToolkit,
+    )
+    from langchain_community.agent_toolkits.sql.base import (
+        create_sql_agent,
+    )
+    from langchain_community.agent_toolkits.sql.toolkit import (
+        SQLDatabaseToolkit,
+    )
+    from langchain_community.agent_toolkits.steam.toolkit import (
+        SteamToolkit,
+    )
+    from langchain_community.agent_toolkits.zapier.toolkit import (
+        ZapierToolkit,
+    )
+
+__all__ = [
+    "AINetworkToolkit",
+    "AmadeusToolkit",
+    "AzureAiServicesToolkit",
+    "AzureCognitiveServicesToolkit",
+    "CogniswitchToolkit",
+    "ConneryToolkit",
+    "FileManagementToolkit",
+    "GmailToolkit",
+    "JiraToolkit",
+    "JsonToolkit",
+    "MultionToolkit",
+    "NLAToolkit",
+    "NasaToolkit",
+    "O365Toolkit",
+    "OpenAPIToolkit",
+    "PlayWrightBrowserToolkit",
+    "PolygonToolkit",
+    "PowerBIToolkit",
+    "SQLDatabaseToolkit",
+    "SlackToolkit",
+    "SparkSQLToolkit",
+    "SteamToolkit",
+    "ZapierToolkit",
+    "create_json_agent",
+    "create_openapi_agent",
+    "create_pbi_agent",
+    "create_pbi_chat_agent",
+    "create_spark_sql_agent",
+    "create_sql_agent",
+]
+
+
+_module_lookup = {
+    "AINetworkToolkit": "langchain_community.agent_toolkits.ainetwork.toolkit",
+    "AmadeusToolkit": "langchain_community.agent_toolkits.amadeus.toolkit",
+    "AzureAiServicesToolkit": "langchain_community.agent_toolkits.azure_ai_services",
+    "AzureCognitiveServicesToolkit": "langchain_community.agent_toolkits.azure_cognitive_services",  # noqa: E501
+    "CogniswitchToolkit": "langchain_community.agent_toolkits.cogniswitch.toolkit",
+    "ConneryToolkit": "langchain_community.agent_toolkits.connery",
+    "FileManagementToolkit": "langchain_community.agent_toolkits.file_management.toolkit",  # noqa: E501
+    "GmailToolkit": "langchain_community.agent_toolkits.gmail.toolkit",
+    "JiraToolkit": "langchain_community.agent_toolkits.jira.toolkit",
+    "JsonToolkit": "langchain_community.agent_toolkits.json.toolkit",
+    "MultionToolkit": "langchain_community.agent_toolkits.multion.toolkit",
+    "NLAToolkit": "langchain_community.agent_toolkits.nla.toolkit",
+    "NasaToolkit": "langchain_community.agent_toolkits.nasa.toolkit",
+    "O365Toolkit": "langchain_community.agent_toolkits.office365.toolkit",
+    "OpenAPIToolkit": "langchain_community.agent_toolkits.openapi.toolkit",
+    "PlayWrightBrowserToolkit": "langchain_community.agent_toolkits.playwright.toolkit",
+    "PolygonToolkit": "langchain_community.agent_toolkits.polygon.toolkit",
+    "PowerBIToolkit": "langchain_community.agent_toolkits.powerbi.toolkit",
+    "SQLDatabaseToolkit": "langchain_community.agent_toolkits.sql.toolkit",
+    "SlackToolkit": "langchain_community.agent_toolkits.slack.toolkit",
+    "SparkSQLToolkit": "langchain_community.agent_toolkits.spark_sql.toolkit",
+    "SteamToolkit": "langchain_community.agent_toolkits.steam.toolkit",
+    "ZapierToolkit": "langchain_community.agent_toolkits.zapier.toolkit",
+    "create_json_agent": "langchain_community.agent_toolkits.json.base",
+    "create_openapi_agent": "langchain_community.agent_toolkits.openapi.base",
+    "create_pbi_agent": "langchain_community.agent_toolkits.powerbi.base",
+    "create_pbi_chat_agent": "langchain_community.agent_toolkits.powerbi.chat_base",
+    "create_spark_sql_agent": "langchain_community.agent_toolkits.spark_sql.base",
+    "create_sql_agent": "langchain_community.agent_toolkits.sql.base",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/agent_toolkits/azure_ai_services.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import List
+
+from langchain_core.tools import BaseTool
+from langchain_core.tools.base import BaseToolkit
+
+from langchain_community.tools.azure_ai_services import (
+    AzureAiServicesDocumentIntelligenceTool,
+    AzureAiServicesImageAnalysisTool,
+    AzureAiServicesSpeechToTextTool,
+    AzureAiServicesTextAnalyticsForHealthTool,
+    AzureAiServicesTextToSpeechTool,
+)
+
+
+class AzureAiServicesToolkit(BaseToolkit):
+    """Toolkit for Azure AI Services."""
+
+    def get_tools(self) -> List[BaseTool]:
+        """Get the tools in the toolkit."""
+
+        tools: List[BaseTool] = [
+            AzureAiServicesDocumentIntelligenceTool(),  # type: ignore[call-arg]
+            AzureAiServicesImageAnalysisTool(),
+            AzureAiServicesSpeechToTextTool(),  # type: ignore[call-arg]
+            AzureAiServicesTextToSpeechTool(),  # type: ignore[call-arg]
+            AzureAiServicesTextAnalyticsForHealthTool(),  # type: ignore[call-arg]
+        ]
+
+        return tools

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/agent_toolkits/azure_cognitive_services.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import sys
+from typing import List
+
+from langchain_core.tools import BaseTool
+from langchain_core.tools.base import BaseToolkit
+
+from langchain_community.tools.azure_cognitive_services import (
+    AzureCogsFormRecognizerTool,
+    AzureCogsImageAnalysisTool,
+    AzureCogsSpeech2TextTool,
+    AzureCogsText2SpeechTool,
+    AzureCogsTextAnalyticsHealthTool,
+)
+
+
+class AzureCognitiveServicesToolkit(BaseToolkit):
+    """Toolkit for Azure Cognitive Services."""
+
+    def get_tools(self) -> List[BaseTool]:
+        """Get the tools in the toolkit."""
+
+        tools: List[BaseTool] = [
+            AzureCogsFormRecognizerTool(),  # type: ignore[call-arg]
+            AzureCogsSpeech2TextTool(),  # type: ignore[call-arg]
+            AzureCogsText2SpeechTool(),  # type: ignore[call-arg]
+            AzureCogsTextAnalyticsHealthTool(),  # type: ignore[call-arg]
+        ]
+
+        # TODO: Remove check once azure-ai-vision supports MacOS.
+        if sys.platform.startswith("linux") or sys.platform.startswith("win"):
+            tools.append(AzureCogsImageAnalysisTool())  # type: ignore[call-arg]
+        return tools

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/agent_toolkits/base.py

@@ -0,0 +1,5 @@
+"""Toolkits for agents."""
+
+from langchain_core.tools.base import BaseToolkit
+
+__all__ = ["BaseToolkit"]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/agent_toolkits/load_tools.py

@@ -0,0 +1,771 @@
+# flake8: noqa
+"""Tools provide access to various resources and services.
+
+LangChain has a large ecosystem of integrations with various external resources
+like local and remote file systems, APIs and databases.
+
+These integrations allow developers to create versatile applications that combine the
+power of LLMs with the ability to access, interact with and manipulate external
+resources.
+
+When developing an application, developers should inspect the capabilities and
+permissions of the tools that underlie the given agent toolkit, and determine
+whether permissions of the given toolkit are appropriate for the application.
+
+See [Security](https://python.langchain.com/docs/security) for more information.
+"""
+
+import warnings
+from typing import Any, Dict, List, Optional, Callable, Tuple
+
+from mypy_extensions import Arg, KwArg
+
+from langchain_community.tools.arxiv.tool import ArxivQueryRun
+from langchain_community.tools.bing_search.tool import BingSearchRun
+from langchain_community.tools.dataforseo_api_search import DataForSeoAPISearchResults
+from langchain_community.tools.dataforseo_api_search import DataForSeoAPISearchRun
+from langchain_community.tools.ddg_search.tool import DuckDuckGoSearchRun
+from langchain_community.tools.eleven_labs.text2speech import ElevenLabsText2SpeechTool
+from langchain_community.tools.file_management import ReadFileTool
+from langchain_community.tools.golden_query.tool import GoldenQueryRun
+from langchain_community.tools.google_cloud.texttospeech import (
+    GoogleCloudTextToSpeechTool,
+)
+from langchain_community.tools.google_finance.tool import GoogleFinanceQueryRun
+from langchain_community.tools.google_jobs.tool import GoogleJobsQueryRun
+from langchain_community.tools.google_lens.tool import GoogleLensQueryRun
+from langchain_community.tools.google_scholar.tool import GoogleScholarQueryRun
+from langchain_community.tools.google_search.tool import (
+    GoogleSearchResults,
+    GoogleSearchRun,
+)
+from langchain_community.tools.google_serper.tool import (
+    GoogleSerperResults,
+    GoogleSerperRun,
+)
+from langchain_community.tools.google_trends.tool import GoogleTrendsQueryRun
+from langchain_community.tools.graphql.tool import BaseGraphQLTool
+from langchain_community.tools.human.tool import HumanInputRun
+from langchain_community.tools.memorize.tool import Memorize
+from langchain_community.tools.merriam_webster.tool import MerriamWebsterQueryRun
+from langchain_community.tools.metaphor_search.tool import MetaphorSearchResults
+from langchain_community.tools.openweathermap.tool import OpenWeatherMapQueryRun
+from langchain_community.tools.pubmed.tool import PubmedQueryRun
+from langchain_community.tools.reddit_search.tool import RedditSearchRun
+from langchain_community.tools.requests.tool import (
+    RequestsDeleteTool,
+    RequestsGetTool,
+    RequestsPatchTool,
+    RequestsPostTool,
+    RequestsPutTool,
+)
+from langchain_community.tools.scenexplain.tool import SceneXplainTool
+from langchain_community.tools.searchapi.tool import SearchAPIResults, SearchAPIRun
+from langchain_community.tools.searx_search.tool import (
+    SearxSearchResults,
+    SearxSearchRun,
+)
+from langchain_community.tools.shell.tool import ShellTool
+from langchain_community.tools.sleep.tool import SleepTool
+from langchain_community.tools.stackexchange.tool import StackExchangeTool
+from langchain_community.tools.wikipedia.tool import WikipediaQueryRun
+from langchain_community.tools.wolfram_alpha.tool import WolframAlphaQueryRun
+from langchain_community.utilities.arxiv import ArxivAPIWrapper
+from langchain_community.utilities.awslambda import LambdaWrapper
+from langchain_community.utilities.bing_search import BingSearchAPIWrapper
+from langchain_community.utilities.dalle_image_generator import DallEAPIWrapper
+from langchain_community.utilities.dataforseo_api_search import DataForSeoAPIWrapper
+from langchain_community.utilities.duckduckgo_search import DuckDuckGoSearchAPIWrapper
+from langchain_community.utilities.golden_query import GoldenQueryAPIWrapper
+from langchain_community.utilities.google_books import GoogleBooksAPIWrapper
+from langchain_community.utilities.google_finance import GoogleFinanceAPIWrapper
+from langchain_community.utilities.google_jobs import GoogleJobsAPIWrapper
+from langchain_community.utilities.google_lens import GoogleLensAPIWrapper
+from langchain_community.utilities.google_scholar import GoogleScholarAPIWrapper
+from langchain_community.utilities.google_search import GoogleSearchAPIWrapper
+from langchain_community.utilities.google_serper import GoogleSerperAPIWrapper
+from langchain_community.utilities.google_trends import GoogleTrendsAPIWrapper
+from langchain_community.utilities.graphql import GraphQLAPIWrapper
+from langchain_community.utilities.merriam_webster import MerriamWebsterAPIWrapper
+from langchain_community.utilities.metaphor_search import MetaphorSearchAPIWrapper
+from langchain_community.utilities.openweathermap import OpenWeatherMapAPIWrapper
+from langchain_community.utilities.pubmed import PubMedAPIWrapper
+from langchain_community.utilities.reddit_search import RedditSearchAPIWrapper
+from langchain_community.utilities.requests import TextRequestsWrapper
+from langchain_community.utilities.searchapi import SearchApiAPIWrapper
+from langchain_community.utilities.searx_search import SearxSearchWrapper
+from langchain_community.utilities.serpapi import SerpAPIWrapper
+from langchain_community.utilities.stackexchange import StackExchangeAPIWrapper
+from langchain_community.utilities.twilio import TwilioAPIWrapper
+from langchain_community.utilities.wikipedia import WikipediaAPIWrapper
+from langchain_community.utilities.wolfram_alpha import WolframAlphaAPIWrapper
+from langchain_core.callbacks import BaseCallbackManager
+from langchain_core.callbacks import Callbacks
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.tools import BaseTool, Tool
+
+
+def _get_tools_requests_get() -> BaseTool:
+    # Dangerous requests are allowed here, because there's another flag that the user
+    # has to provide in order to actually opt in.
+    # This is a private function and should not be used directly.
+    return RequestsGetTool(
+        requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True
+    )
+
+
+def _get_tools_requests_post() -> BaseTool:
+    # Dangerous requests are allowed here, because there's another flag that the user
+    # has to provide in order to actually opt in.
+    # This is a private function and should not be used directly.
+    return RequestsPostTool(
+        requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True
+    )
+
+
+def _get_tools_requests_patch() -> BaseTool:
+    # Dangerous requests are allowed here, because there's another flag that the user
+    # has to provide in order to actually opt in.
+    # This is a private function and should not be used directly.
+    return RequestsPatchTool(
+        requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True
+    )
+
+
+def _get_tools_requests_put() -> BaseTool:
+    # Dangerous requests are allowed here, because there's another flag that the user
+    # has to provide in order to actually opt in.
+    # This is a private function and should not be used directly.
+    return RequestsPutTool(
+        requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True
+    )
+
+
+def _get_tools_requests_delete() -> BaseTool:
+    # Dangerous requests are allowed here, because there's another flag that the user
+    # has to provide in order to actually opt in.
+    # This is a private function and should not be used directly.
+    return RequestsDeleteTool(
+        requests_wrapper=TextRequestsWrapper(), allow_dangerous_requests=True
+    )
+
+
+def _get_terminal() -> BaseTool:
+    return ShellTool()
+
+
+def _get_sleep() -> BaseTool:
+    return SleepTool()
+
+
+_BASE_TOOLS: Dict[str, Callable[[], BaseTool]] = {
+    "sleep": _get_sleep,
+}
+
+DANGEROUS_TOOLS = {
+    # Tools that contain some level of risk.
+    # Please use with caution and read the documentation of these tools
+    # to understand the risks and how to mitigate them.
+    # Refer to https://python.langchain.com/docs/security
+    # for more information.
+    "requests": _get_tools_requests_get,  # preserved for backwards compatibility
+    "requests_get": _get_tools_requests_get,
+    "requests_post": _get_tools_requests_post,
+    "requests_patch": _get_tools_requests_patch,
+    "requests_put": _get_tools_requests_put,
+    "requests_delete": _get_tools_requests_delete,
+    "terminal": _get_terminal,
+}
+
+
+def _get_llm_math(llm: BaseLanguageModel) -> BaseTool:
+    try:
+        from langchain_classic.chains.llm_math.base import LLMMathChain
+    except ImportError:
+        raise ImportError(
+            "LLM Math tools require the library `langchain` to be installed."
+            " Please install it with `pip install langchain`."
+        )
+    return Tool(
+        name="Calculator",
+        description="Useful for when you need to answer questions about math.",
+        func=LLMMathChain.from_llm(llm=llm).run,
+        coroutine=LLMMathChain.from_llm(llm=llm).arun,
+    )
+
+
+def _get_open_meteo_api(llm: BaseLanguageModel) -> BaseTool:
+    try:
+        from langchain_classic.chains.api.base import APIChain
+        from langchain_classic.chains.api import (
+            open_meteo_docs,
+        )
+    except ImportError:
+        raise ImportError(
+            "API tools require the library `langchain` to be installed."
+            " Please install it with `pip install langchain`."
+        )
+    chain = APIChain.from_llm_and_api_docs(
+        llm,
+        open_meteo_docs.OPEN_METEO_DOCS,
+        limit_to_domains=["https://api.open-meteo.com/"],
+    )
+    return Tool(
+        name="Open-Meteo-API",
+        description="Useful for when you want to get weather information from the OpenMeteo API. The input should be a question in natural language that this API can answer.",
+        func=chain.run,
+    )
+
+
+_LLM_TOOLS: Dict[str, Callable[[BaseLanguageModel], BaseTool]] = {
+    "llm-math": _get_llm_math,
+    "open-meteo-api": _get_open_meteo_api,
+}
+
+
+def _get_news_api(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool:
+    news_api_key = kwargs["news_api_key"]
+    try:
+        from langchain_classic.chains.api.base import APIChain
+        from langchain_classic.chains.api import (
+            news_docs,
+        )
+    except ImportError:
+        raise ImportError(
+            "API tools require the library `langchain` to be installed."
+            " Please install it with `pip install langchain`."
+        )
+    chain = APIChain.from_llm_and_api_docs(
+        llm,
+        news_docs.NEWS_DOCS,
+        headers={"X-Api-Key": news_api_key},
+        limit_to_domains=["https://newsapi.org/"],
+    )
+    return Tool(
+        name="News-API",
+        description="Use this when you want to get information about the top headlines of current news stories. The input should be a question in natural language that this API can answer.",
+        func=chain.run,
+    )
+
+
+def _get_tmdb_api(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool:
+    tmdb_bearer_token = kwargs["tmdb_bearer_token"]
+    try:
+        from langchain_classic.chains.api.base import APIChain
+        from langchain_classic.chains.api import (
+            tmdb_docs,
+        )
+    except ImportError:
+        raise ImportError(
+            "API tools require the library `langchain` to be installed."
+            " Please install it with `pip install langchain`."
+        )
+    chain = APIChain.from_llm_and_api_docs(
+        llm,
+        tmdb_docs.TMDB_DOCS,
+        headers={"Authorization": f"Bearer {tmdb_bearer_token}"},
+        limit_to_domains=["https://api.themoviedb.org/"],
+    )
+    return Tool(
+        name="TMDB-API",
+        description="Useful for when you want to get information from The Movie Database. The input should be a question in natural language that this API can answer.",
+        func=chain.run,
+    )
+
+
+def _get_podcast_api(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool:
+    listen_api_key = kwargs["listen_api_key"]
+    try:
+        from langchain_classic.chains.api.base import APIChain
+        from langchain_classic.chains.api import (
+            podcast_docs,
+        )
+    except ImportError:
+        raise ImportError(
+            "API tools require the library `langchain` to be installed."
+            " Please install it with `pip install langchain`."
+        )
+    chain = APIChain.from_llm_and_api_docs(
+        llm,
+        podcast_docs.PODCAST_DOCS,
+        headers={"X-ListenAPI-Key": listen_api_key},
+        limit_to_domains=["https://listen-api.listennotes.com/"],
+    )
+    return Tool(
+        name="Podcast-API",
+        description="Use the Listen Notes Podcast API to search all podcasts or episodes. The input should be a question in natural language that this API can answer.",
+        func=chain.run,
+    )
+
+
+def _get_lambda_api(**kwargs: Any) -> BaseTool:
+    return Tool(
+        name=kwargs["awslambda_tool_name"],
+        description=kwargs["awslambda_tool_description"],
+        func=LambdaWrapper(**kwargs).run,
+    )
+
+
+def _get_wolfram_alpha(**kwargs: Any) -> BaseTool:
+    return WolframAlphaQueryRun(api_wrapper=WolframAlphaAPIWrapper(**kwargs))
+
+
+def _get_google_search(**kwargs: Any) -> BaseTool:
+    return GoogleSearchRun(api_wrapper=GoogleSearchAPIWrapper(**kwargs))
+
+
+def _get_merriam_webster(**kwargs: Any) -> BaseTool:
+    return MerriamWebsterQueryRun(api_wrapper=MerriamWebsterAPIWrapper(**kwargs))
+
+
+def _get_wikipedia(**kwargs: Any) -> BaseTool:
+    return WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper(**kwargs))
+
+
+def _get_arxiv(**kwargs: Any) -> BaseTool:
+    return ArxivQueryRun(api_wrapper=ArxivAPIWrapper(**kwargs))
+
+
+def _get_golden_query(**kwargs: Any) -> BaseTool:
+    return GoldenQueryRun(api_wrapper=GoldenQueryAPIWrapper(**kwargs))
+
+
+def _get_pubmed(**kwargs: Any) -> BaseTool:
+    return PubmedQueryRun(api_wrapper=PubMedAPIWrapper(**kwargs))
+
+
+def _get_google_books(**kwargs: Any) -> BaseTool:
+    from langchain_community.tools.google_books import GoogleBooksQueryRun
+
+    return GoogleBooksQueryRun(api_wrapper=GoogleBooksAPIWrapper(**kwargs))
+
+
+def _get_google_jobs(**kwargs: Any) -> BaseTool:
+    return GoogleJobsQueryRun(api_wrapper=GoogleJobsAPIWrapper(**kwargs))
+
+
+def _get_google_lens(**kwargs: Any) -> BaseTool:
+    return GoogleLensQueryRun(api_wrapper=GoogleLensAPIWrapper(**kwargs))
+
+
+def _get_google_serper(**kwargs: Any) -> BaseTool:
+    return GoogleSerperRun(api_wrapper=GoogleSerperAPIWrapper(**kwargs))
+
+
+def _get_google_scholar(**kwargs: Any) -> BaseTool:
+    return GoogleScholarQueryRun(api_wrapper=GoogleScholarAPIWrapper(**kwargs))
+
+
+def _get_google_finance(**kwargs: Any) -> BaseTool:
+    return GoogleFinanceQueryRun(api_wrapper=GoogleFinanceAPIWrapper(**kwargs))
+
+
+def _get_google_trends(**kwargs: Any) -> BaseTool:
+    return GoogleTrendsQueryRun(api_wrapper=GoogleTrendsAPIWrapper(**kwargs))
+
+
+def _get_google_serper_results_json(**kwargs: Any) -> BaseTool:
+    return GoogleSerperResults(api_wrapper=GoogleSerperAPIWrapper(**kwargs))
+
+
+def _get_google_search_results_json(**kwargs: Any) -> BaseTool:
+    return GoogleSearchResults(api_wrapper=GoogleSearchAPIWrapper(**kwargs))
+
+
+def _get_searchapi(**kwargs: Any) -> BaseTool:
+    return SearchAPIRun(api_wrapper=SearchApiAPIWrapper(**kwargs))
+
+
+def _get_searchapi_results_json(**kwargs: Any) -> BaseTool:
+    return SearchAPIResults(api_wrapper=SearchApiAPIWrapper(**kwargs))
+
+
+def _get_serpapi(**kwargs: Any) -> BaseTool:
+    return Tool(
+        name="Search",
+        description="A search engine. Useful for when you need to answer questions about current events. Input should be a search query.",
+        func=SerpAPIWrapper(**kwargs).run,
+        coroutine=SerpAPIWrapper(**kwargs).arun,
+    )
+
+
+def _get_stackexchange(**kwargs: Any) -> BaseTool:
+    return StackExchangeTool(api_wrapper=StackExchangeAPIWrapper(**kwargs))
+
+
+def _get_dalle_image_generator(**kwargs: Any) -> Tool:
+    return Tool(
+        "Dall-E-Image-Generator",
+        DallEAPIWrapper(**kwargs).run,
+        "A wrapper around OpenAI DALL-E API. Useful for when you need to generate images from a text description. Input should be an image description.",
+    )
+
+
+def _get_twilio(**kwargs: Any) -> BaseTool:
+    return Tool(
+        name="Text-Message",
+        description="Useful for when you need to send a text message to a provided phone number.",
+        func=TwilioAPIWrapper(**kwargs).run,
+    )
+
+
+def _get_searx_search(**kwargs: Any) -> BaseTool:
+    return SearxSearchRun(wrapper=SearxSearchWrapper(**kwargs))
+
+
+def _get_searx_search_results_json(**kwargs: Any) -> BaseTool:
+    wrapper_kwargs = {k: v for k, v in kwargs.items() if k != "num_results"}
+    return SearxSearchResults(wrapper=SearxSearchWrapper(**wrapper_kwargs), **kwargs)
+
+
+def _get_bing_search(**kwargs: Any) -> BaseTool:
+    return BingSearchRun(api_wrapper=BingSearchAPIWrapper(**kwargs))
+
+
+def _get_metaphor_search(**kwargs: Any) -> BaseTool:
+    return MetaphorSearchResults(api_wrapper=MetaphorSearchAPIWrapper(**kwargs))
+
+
+def _get_ddg_search(**kwargs: Any) -> BaseTool:
+    return DuckDuckGoSearchRun(api_wrapper=DuckDuckGoSearchAPIWrapper(**kwargs))
+
+
+def _get_human_tool(**kwargs: Any) -> BaseTool:
+    return HumanInputRun(**kwargs)
+
+
+def _get_scenexplain(**kwargs: Any) -> BaseTool:
+    return SceneXplainTool(**kwargs)
+
+
+def _get_graphql_tool(**kwargs: Any) -> BaseTool:
+    return BaseGraphQLTool(graphql_wrapper=GraphQLAPIWrapper(**kwargs))
+
+
+def _get_openweathermap(**kwargs: Any) -> BaseTool:
+    return OpenWeatherMapQueryRun(api_wrapper=OpenWeatherMapAPIWrapper(**kwargs))
+
+
+def _get_dataforseo_api_search(**kwargs: Any) -> BaseTool:
+    return DataForSeoAPISearchRun(api_wrapper=DataForSeoAPIWrapper(**kwargs))
+
+
+def _get_dataforseo_api_search_json(**kwargs: Any) -> BaseTool:
+    return DataForSeoAPISearchResults(api_wrapper=DataForSeoAPIWrapper(**kwargs))
+
+
+def _get_eleven_labs_text2speech(**kwargs: Any) -> BaseTool:
+    return ElevenLabsText2SpeechTool(**kwargs)
+
+
+def _get_memorize(llm: BaseLanguageModel, **kwargs: Any) -> BaseTool:
+    return Memorize(llm=llm)  # type: ignore[arg-type]
+
+
+def _get_google_cloud_texttospeech(**kwargs: Any) -> BaseTool:
+    return GoogleCloudTextToSpeechTool(**kwargs)
+
+
+def _get_file_management_tool(**kwargs: Any) -> BaseTool:
+    return ReadFileTool(**kwargs)
+
+
+def _get_reddit_search(**kwargs: Any) -> BaseTool:
+    return RedditSearchRun(api_wrapper=RedditSearchAPIWrapper(**kwargs))
+
+
+_EXTRA_LLM_TOOLS: Dict[
+    str,
+    Tuple[Callable[[Arg(BaseLanguageModel, "llm"), KwArg(Any)], BaseTool], List[str]],
+] = {
+    "news-api": (_get_news_api, ["news_api_key"]),
+    "tmdb-api": (_get_tmdb_api, ["tmdb_bearer_token"]),
+    "podcast-api": (_get_podcast_api, ["listen_api_key"]),
+    "memorize": (_get_memorize, []),
+}
+_EXTRA_OPTIONAL_TOOLS: Dict[str, Tuple[Callable[[KwArg(Any)], BaseTool], List[str]]] = {
+    "wolfram-alpha": (_get_wolfram_alpha, ["wolfram_alpha_appid"]),
+    "google-search": (_get_google_search, ["google_api_key", "google_cse_id"]),
+    "google-search-results-json": (
+        _get_google_search_results_json,
+        ["google_api_key", "google_cse_id", "num_results"],
+    ),
+    "searx-search-results-json": (
+        _get_searx_search_results_json,
+        ["searx_host", "engines", "num_results", "aiosession"],
+    ),
+    "bing-search": (_get_bing_search, ["bing_subscription_key", "bing_search_url"]),
+    "metaphor-search": (_get_metaphor_search, ["metaphor_api_key"]),
+    "ddg-search": (_get_ddg_search, []),
+    "google-books": (_get_google_books, ["google_books_api_key"]),
+    "google-lens": (_get_google_lens, ["serp_api_key"]),
+    "google-serper": (_get_google_serper, ["serper_api_key", "aiosession"]),
+    "google-scholar": (
+        _get_google_scholar,
+        ["top_k_results", "hl", "lr", "serp_api_key"],
+    ),
+    "google-finance": (
+        _get_google_finance,
+        ["serp_api_key"],
+    ),
+    "google-trends": (
+        _get_google_trends,
+        ["serp_api_key"],
+    ),
+    "google-jobs": (
+        _get_google_jobs,
+        ["serp_api_key"],
+    ),
+    "google-serper-results-json": (
+        _get_google_serper_results_json,
+        ["serper_api_key", "aiosession"],
+    ),
+    "searchapi": (_get_searchapi, ["searchapi_api_key", "aiosession"]),
+    "searchapi-results-json": (
+        _get_searchapi_results_json,
+        ["searchapi_api_key", "aiosession"],
+    ),
+    "serpapi": (_get_serpapi, ["serpapi_api_key", "aiosession"]),
+    "dalle-image-generator": (_get_dalle_image_generator, ["openai_api_key"]),
+    "twilio": (_get_twilio, ["account_sid", "auth_token", "from_number"]),
+    "searx-search": (_get_searx_search, ["searx_host", "engines", "aiosession"]),
+    "merriam-webster": (_get_merriam_webster, ["merriam_webster_api_key"]),
+    "wikipedia": (_get_wikipedia, ["top_k_results", "lang"]),
+    "arxiv": (
+        _get_arxiv,
+        ["top_k_results", "load_max_docs", "load_all_available_meta"],
+    ),
+    "golden-query": (_get_golden_query, ["golden_api_key"]),
+    "pubmed": (_get_pubmed, ["top_k_results"]),
+    "human": (_get_human_tool, ["prompt_func", "input_func"]),
+    "awslambda": (
+        _get_lambda_api,
+        ["awslambda_tool_name", "awslambda_tool_description", "function_name"],
+    ),
+    "stackexchange": (_get_stackexchange, []),
+    "sceneXplain": (_get_scenexplain, []),
+    "graphql": (
+        _get_graphql_tool,
+        ["graphql_endpoint", "custom_headers", "fetch_schema_from_transport"],
+    ),
+    "openweathermap-api": (_get_openweathermap, ["openweathermap_api_key"]),
+    "dataforseo-api-search": (
+        _get_dataforseo_api_search,
+        ["api_login", "api_password", "aiosession"],
+    ),
+    "dataforseo-api-search-json": (
+        _get_dataforseo_api_search_json,
+        ["api_login", "api_password", "aiosession"],
+    ),
+    "eleven_labs_text2speech": (_get_eleven_labs_text2speech, ["elevenlabs_api_key"]),
+    "google_cloud_texttospeech": (_get_google_cloud_texttospeech, []),
+    "read_file": (_get_file_management_tool, []),
+    "reddit_search": (
+        _get_reddit_search,
+        ["reddit_client_id", "reddit_client_secret", "reddit_user_agent"],
+    ),
+}
+
+
+def _handle_callbacks(
+    callback_manager: Optional[BaseCallbackManager], callbacks: Callbacks
+) -> Callbacks:
+    if callback_manager is not None:
+        warnings.warn(
+            "callback_manager is deprecated. Please use callbacks instead.",
+            DeprecationWarning,
+        )
+        if callbacks is not None:
+            raise ValueError(
+                "Cannot specify both callback_manager and callbacks arguments."
+            )
+        return callback_manager
+    return callbacks
+
+
+def load_huggingface_tool(
+    task_or_repo_id: str,
+    model_repo_id: Optional[str] = None,
+    token: Optional[str] = None,
+    remote: bool = False,
+    **kwargs: Any,
+) -> BaseTool:
+    """Loads a tool from the HuggingFace Hub.
+
+    Args:
+        task_or_repo_id: Task or model repo id.
+        model_repo_id: Optional model repo id. Defaults to None.
+        token: Optional token. Defaults to None.
+        remote: Optional remote. Defaults to False.
+        kwargs: Additional keyword arguments.
+
+    Returns:
+        A tool.
+
+    Raises:
+        ImportError: If the required libraries are not installed.
+        NotImplementedError: If multimodal outputs or inputs are not supported.
+    """
+    try:
+        from transformers import load_tool
+    except ImportError:
+        raise ImportError(
+            "HuggingFace tools require the libraries `transformers>=4.29.0`"
+            " and `huggingface_hub>=0.14.1` to be installed."
+            " Please install it with"
+            " `pip install --upgrade transformers huggingface_hub`."
+        )
+    hf_tool = load_tool(
+        task_or_repo_id,
+        model_repo_id=model_repo_id,
+        token=token,
+        remote=remote,
+        **kwargs,
+    )
+    outputs = hf_tool.outputs
+    if set(outputs) != {"text"}:
+        raise NotImplementedError("Multimodal outputs not supported yet.")
+    inputs = hf_tool.inputs
+    if set(inputs) != {"text"}:
+        raise NotImplementedError("Multimodal inputs not supported yet.")
+    return Tool.from_function(
+        hf_tool.__call__, name=hf_tool.name, description=hf_tool.description
+    )
+
+
+def raise_dangerous_tools_exception(name: str) -> None:
+    raise ValueError(
+        f"{name} is a dangerous tool. You cannot use it without opting in "
+        "by setting allow_dangerous_tools to True. "
+        "Most tools have some inherit risk to them merely because they are "
+        'allowed to interact with the "real world".'
+        "Please refer to LangChain security guidelines "
+        "to https://python.langchain.com/docs/security."
+        "Some tools have been designated as dangerous because they pose "
+        "risk that is not intuitively obvious. For example, a tool that "
+        "allows an agent to make requests to the web, can also be used "
+        "to make requests to a server that is only accessible from the "
+        "server hosting the code."
+        "Again, all tools carry some risk, and it's your responsibility to "
+        "understand which tools you're using and the risks associated with "
+        "them."
+    )
+
+
+def load_tools(
+    tool_names: List[str],
+    llm: Optional[BaseLanguageModel] = None,
+    callbacks: Callbacks = None,
+    allow_dangerous_tools: bool = False,
+    **kwargs: Any,
+) -> List[BaseTool]:
+    """Load tools based on their name.
+
+    Tools allow agents to interact with various resources and services like
+    APIs, databases, file systems, etc.
+
+    Please scope the permissions of each tools to the minimum required for the
+    application.
+
+    For example, if an application only needs to read from a database,
+    the database tool should not be given write permissions. Moreover
+    consider scoping the permissions to only allow accessing specific
+    tables and impose user-level quota for limiting resource usage.
+
+    Please read the APIs of the individual tools to determine which configuration
+    they support.
+
+    See [Security](https://python.langchain.com/docs/security) for more information.
+
+    Args:
+        tool_names: name of tools to load.
+        llm: An optional language model may be needed to initialize certain tools.
+            Defaults to None.
+        callbacks: Optional callback manager or list of callback handlers.
+            If not provided, default global callback manager will be used.
+        allow_dangerous_tools: Optional flag to allow dangerous tools.
+            Tools that contain some level of risk.
+            Please use with caution and read the documentation of these tools
+            to understand the risks and how to mitigate them.
+            Refer to https://python.langchain.com/docs/security
+            for more information.
+            Please note that this list may not be fully exhaustive.
+            It is your responsibility to understand which tools
+            you're using and the risks associated with them.
+            Defaults to False.
+        kwargs: Additional keyword arguments.
+
+    Returns:
+        List of tools.
+
+    Raises:
+        ValueError: If the tool name is unknown.
+        ValueError: If the tool requires an LLM to be provided.
+        ValueError: If the tool requires some parameters that were not provided.
+        ValueError: If the tool is a dangerous tool and allow_dangerous_tools is False.
+    """
+    tools = []
+    callbacks = _handle_callbacks(
+        callback_manager=kwargs.get("callback_manager"), callbacks=callbacks
+    )
+    for name in tool_names:
+        if name in DANGEROUS_TOOLS and not allow_dangerous_tools:
+            raise_dangerous_tools_exception(name)
+
+        if name in {"requests"}:
+            warnings.warn(
+                "tool name `requests` is deprecated - "
+                "please use `requests_all` or specify the requests method"
+            )
+        if name == "requests_all":
+            # expand requests into various methods
+            if not allow_dangerous_tools:
+                raise_dangerous_tools_exception(name)
+            requests_method_tools = [
+                _tool for _tool in DANGEROUS_TOOLS if _tool.startswith("requests_")
+            ]
+            tool_names.extend(requests_method_tools)
+        elif name in _BASE_TOOLS:
+            tools.append(_BASE_TOOLS[name]())
+        elif name in DANGEROUS_TOOLS:
+            tools.append(DANGEROUS_TOOLS[name]())
+        elif name in _LLM_TOOLS:
+            if llm is None:
+                raise ValueError(f"Tool {name} requires an LLM to be provided")
+            tool = _LLM_TOOLS[name](llm)
+            tools.append(tool)
+        elif name in _EXTRA_LLM_TOOLS:
+            if llm is None:
+                raise ValueError(f"Tool {name} requires an LLM to be provided")
+            _get_llm_tool_func, extra_keys = _EXTRA_LLM_TOOLS[name]
+            missing_keys = set(extra_keys).difference(kwargs)
+            if missing_keys:
+                raise ValueError(
+                    f"Tool {name} requires some parameters that were not "
+                    f"provided: {missing_keys}"
+                )
+            sub_kwargs = {k: kwargs[k] for k in extra_keys}
+            tool = _get_llm_tool_func(llm=llm, **sub_kwargs)
+            tools.append(tool)
+        elif name in _EXTRA_OPTIONAL_TOOLS:
+            _get_tool_func, extra_keys = _EXTRA_OPTIONAL_TOOLS[name]
+            sub_kwargs = {k: kwargs[k] for k in extra_keys if k in kwargs}
+            tool = _get_tool_func(**sub_kwargs)
+            tools.append(tool)
+        else:
+            raise ValueError(f"Got unknown tool {name}")
+    if callbacks is not None:
+        for tool in tools:
+            tool.callbacks = callbacks
+    return tools
+
+
+def get_all_tool_names() -> List[str]:
+    """Get a list of all possible tool names."""
+    return (
+        list(_BASE_TOOLS)
+        + list(_EXTRA_OPTIONAL_TOOLS)
+        + list(_EXTRA_LLM_TOOLS)
+        + list(_LLM_TOOLS)
+        + list(DANGEROUS_TOOLS)
+    )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/__init__.py

@@ -0,0 +1,157 @@
+"""**Callback handlers** allow listening to events in LangChain.
+
+**Class hierarchy:**
+
+.. code-block::
+
+    BaseCallbackHandler --> <name>CallbackHandler  # Example: AimCallbackHandler
+"""
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.callbacks.aim_callback import (
+        AimCallbackHandler,
+    )
+    from langchain_community.callbacks.argilla_callback import (
+        ArgillaCallbackHandler,
+    )
+    from langchain_community.callbacks.arize_callback import (
+        ArizeCallbackHandler,
+    )
+    from langchain_community.callbacks.arthur_callback import (
+        ArthurCallbackHandler,
+    )
+    from langchain_community.callbacks.clearml_callback import (
+        ClearMLCallbackHandler,
+    )
+    from langchain_community.callbacks.comet_ml_callback import (
+        CometCallbackHandler,
+    )
+    from langchain_community.callbacks.context_callback import (
+        ContextCallbackHandler,
+    )
+    from langchain_community.callbacks.fiddler_callback import (
+        FiddlerCallbackHandler,
+    )
+    from langchain_community.callbacks.flyte_callback import (
+        FlyteCallbackHandler,
+    )
+    from langchain_community.callbacks.human import (
+        HumanApprovalCallbackHandler,
+    )
+    from langchain_community.callbacks.infino_callback import (
+        InfinoCallbackHandler,
+    )
+    from langchain_community.callbacks.labelstudio_callback import (
+        LabelStudioCallbackHandler,
+    )
+    from langchain_community.callbacks.llmonitor_callback import (
+        LLMonitorCallbackHandler,
+    )
+    from langchain_community.callbacks.manager import (
+        get_openai_callback,
+        wandb_tracing_enabled,
+    )
+    from langchain_community.callbacks.mlflow_callback import (
+        MlflowCallbackHandler,
+    )
+    from langchain_community.callbacks.openai_info import (
+        OpenAICallbackHandler,
+    )
+    from langchain_community.callbacks.promptlayer_callback import (
+        PromptLayerCallbackHandler,
+    )
+    from langchain_community.callbacks.sagemaker_callback import (
+        SageMakerCallbackHandler,
+    )
+    from langchain_community.callbacks.streamlit import (
+        LLMThoughtLabeler,
+        StreamlitCallbackHandler,
+    )
+    from langchain_community.callbacks.trubrics_callback import (
+        TrubricsCallbackHandler,
+    )
+    from langchain_community.callbacks.upstash_ratelimit_callback import (
+        UpstashRatelimitError,
+        UpstashRatelimitHandler,  # noqa: F401
+    )
+    from langchain_community.callbacks.uptrain_callback import (
+        UpTrainCallbackHandler,
+    )
+    from langchain_community.callbacks.wandb_callback import (
+        WandbCallbackHandler,
+    )
+    from langchain_community.callbacks.whylabs_callback import (
+        WhyLabsCallbackHandler,
+    )
+
+
+_module_lookup = {
+    "AimCallbackHandler": "langchain_community.callbacks.aim_callback",
+    "ArgillaCallbackHandler": "langchain_community.callbacks.argilla_callback",
+    "ArizeCallbackHandler": "langchain_community.callbacks.arize_callback",
+    "ArthurCallbackHandler": "langchain_community.callbacks.arthur_callback",
+    "ClearMLCallbackHandler": "langchain_community.callbacks.clearml_callback",
+    "CometCallbackHandler": "langchain_community.callbacks.comet_ml_callback",
+    "ContextCallbackHandler": "langchain_community.callbacks.context_callback",
+    "FiddlerCallbackHandler": "langchain_community.callbacks.fiddler_callback",
+    "FlyteCallbackHandler": "langchain_community.callbacks.flyte_callback",
+    "HumanApprovalCallbackHandler": "langchain_community.callbacks.human",
+    "InfinoCallbackHandler": "langchain_community.callbacks.infino_callback",
+    "LLMThoughtLabeler": "langchain_community.callbacks.streamlit",
+    "LLMonitorCallbackHandler": "langchain_community.callbacks.llmonitor_callback",
+    "LabelStudioCallbackHandler": "langchain_community.callbacks.labelstudio_callback",
+    "MlflowCallbackHandler": "langchain_community.callbacks.mlflow_callback",
+    "OpenAICallbackHandler": "langchain_community.callbacks.openai_info",
+    "PromptLayerCallbackHandler": "langchain_community.callbacks.promptlayer_callback",
+    "SageMakerCallbackHandler": "langchain_community.callbacks.sagemaker_callback",
+    "StreamlitCallbackHandler": "langchain_community.callbacks.streamlit",
+    "TrubricsCallbackHandler": "langchain_community.callbacks.trubrics_callback",
+    "UpstashRatelimitError": "langchain_community.callbacks.upstash_ratelimit_callback",
+    "UpstashRatelimitHandler": "langchain_community.callbacks.upstash_ratelimit_callback",  # noqa
+    "UpTrainCallbackHandler": "langchain_community.callbacks.uptrain_callback",
+    "WandbCallbackHandler": "langchain_community.callbacks.wandb_callback",
+    "WhyLabsCallbackHandler": "langchain_community.callbacks.whylabs_callback",
+    "get_openai_callback": "langchain_community.callbacks.manager",
+    "wandb_tracing_enabled": "langchain_community.callbacks.manager",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")
+
+
+__all__ = [
+    "AimCallbackHandler",
+    "ArgillaCallbackHandler",
+    "ArizeCallbackHandler",
+    "ArthurCallbackHandler",
+    "ClearMLCallbackHandler",
+    "CometCallbackHandler",
+    "ContextCallbackHandler",
+    "FiddlerCallbackHandler",
+    "FlyteCallbackHandler",
+    "HumanApprovalCallbackHandler",
+    "InfinoCallbackHandler",
+    "LLMThoughtLabeler",
+    "LLMonitorCallbackHandler",
+    "LabelStudioCallbackHandler",
+    "MlflowCallbackHandler",
+    "OpenAICallbackHandler",
+    "PromptLayerCallbackHandler",
+    "SageMakerCallbackHandler",
+    "StreamlitCallbackHandler",
+    "TrubricsCallbackHandler",
+    "UpstashRatelimitError",
+    "UpstashRatelimitHandler",
+    "UpTrainCallbackHandler",
+    "WandbCallbackHandler",
+    "WhyLabsCallbackHandler",
+    "get_openai_callback",
+    "wandb_tracing_enabled",
+]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/aim_callback.py

@@ -0,0 +1,434 @@
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+
+def import_aim() -> Any:
+    """Import the aim python package and raise an error if it is not installed."""
+    return guard_import("aim")
+
+
+class BaseMetadataCallbackHandler:
+    """Callback handler for the metadata and associated function states for callbacks.
+
+    Attributes:
+        step (int): The current step.
+        starts (int): The number of times the start method has been called.
+        ends (int): The number of times the end method has been called.
+        errors (int): The number of times the error method has been called.
+        text_ctr (int): The number of times the text method has been called.
+        ignore_llm_ (bool): Whether to ignore llm callbacks.
+        ignore_chain_ (bool): Whether to ignore chain callbacks.
+        ignore_agent_ (bool): Whether to ignore agent callbacks.
+        ignore_retriever_ (bool): Whether to ignore retriever callbacks.
+        always_verbose_ (bool): Whether to always be verbose.
+        chain_starts (int): The number of times the chain start method has been called.
+        chain_ends (int): The number of times the chain end method has been called.
+        llm_starts (int): The number of times the llm start method has been called.
+        llm_ends (int): The number of times the llm end method has been called.
+        llm_streams (int): The number of times the text method has been called.
+        tool_starts (int): The number of times the tool start method has been called.
+        tool_ends (int): The number of times the tool end method has been called.
+        agent_ends (int): The number of times the agent end method has been called.
+    """
+
+    def __init__(self) -> None:
+        self.step = 0
+
+        self.starts = 0
+        self.ends = 0
+        self.errors = 0
+        self.text_ctr = 0
+
+        self.ignore_llm_ = False
+        self.ignore_chain_ = False
+        self.ignore_agent_ = False
+        self.ignore_retriever_ = False
+        self.always_verbose_ = False
+
+        self.chain_starts = 0
+        self.chain_ends = 0
+
+        self.llm_starts = 0
+        self.llm_ends = 0
+        self.llm_streams = 0
+
+        self.tool_starts = 0
+        self.tool_ends = 0
+
+        self.agent_ends = 0
+
+    @property
+    def always_verbose(self) -> bool:
+        """Whether to call verbose callbacks even if verbose is False."""
+        return self.always_verbose_
+
+    @property
+    def ignore_llm(self) -> bool:
+        """Whether to ignore LLM callbacks."""
+        return self.ignore_llm_
+
+    @property
+    def ignore_chain(self) -> bool:
+        """Whether to ignore chain callbacks."""
+        return self.ignore_chain_
+
+    @property
+    def ignore_agent(self) -> bool:
+        """Whether to ignore agent callbacks."""
+        return self.ignore_agent_
+
+    @property
+    def ignore_retriever(self) -> bool:
+        """Whether to ignore retriever callbacks."""
+        return self.ignore_retriever_
+
+    def get_custom_callback_meta(self) -> Dict[str, Any]:
+        return {
+            "step": self.step,
+            "starts": self.starts,
+            "ends": self.ends,
+            "errors": self.errors,
+            "text_ctr": self.text_ctr,
+            "chain_starts": self.chain_starts,
+            "chain_ends": self.chain_ends,
+            "llm_starts": self.llm_starts,
+            "llm_ends": self.llm_ends,
+            "llm_streams": self.llm_streams,
+            "tool_starts": self.tool_starts,
+            "tool_ends": self.tool_ends,
+            "agent_ends": self.agent_ends,
+        }
+
+    def reset_callback_meta(self) -> None:
+        """Reset the callback metadata."""
+        self.step = 0
+
+        self.starts = 0
+        self.ends = 0
+        self.errors = 0
+        self.text_ctr = 0
+
+        self.ignore_llm_ = False
+        self.ignore_chain_ = False
+        self.ignore_agent_ = False
+        self.always_verbose_ = False
+
+        self.chain_starts = 0
+        self.chain_ends = 0
+
+        self.llm_starts = 0
+        self.llm_ends = 0
+        self.llm_streams = 0
+
+        self.tool_starts = 0
+        self.tool_ends = 0
+
+        self.agent_ends = 0
+
+        return None
+
+
+class AimCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """Callback Handler that logs to Aim.
+
+    Parameters:
+        repo (:obj:`str`, optional): Aim repository path or Repo object to which
+            Run object is bound. If skipped, default Repo is used.
+        experiment_name (:obj:`str`, optional): Sets Run's `experiment` property.
+            'default' if not specified. Can be used later to query runs/sequences.
+        system_tracking_interval (:obj:`int`, optional): Sets the tracking interval
+            in seconds for system usage metrics (CPU, Memory, etc.). Set to `None`
+             to disable system metrics tracking.
+        log_system_params (:obj:`bool`, optional): Enable/Disable logging of system
+            params such as installed packages, git info, environment variables, etc.
+
+    This handler will utilize the associated callback method called and formats
+    the input of each callback function with metadata regarding the state of LLM run
+    and then logs the response to Aim.
+    """
+
+    def __init__(
+        self,
+        repo: Optional[str] = None,
+        experiment_name: Optional[str] = None,
+        system_tracking_interval: Optional[int] = 10,
+        log_system_params: bool = True,
+    ) -> None:
+        """Initialize callback handler."""
+
+        super().__init__()
+
+        aim = import_aim()
+        self.repo = repo
+        self.experiment_name = experiment_name
+        self.system_tracking_interval = system_tracking_interval
+        self.log_system_params = log_system_params
+        self._run = aim.Run(
+            repo=self.repo,
+            experiment=self.experiment_name,
+            system_tracking_interval=self.system_tracking_interval,
+            log_system_params=self.log_system_params,
+        )
+        self._run_hash = self._run.hash
+        self.action_records: list = []
+
+    def setup(self, **kwargs: Any) -> None:
+        aim = import_aim()
+
+        if not self._run:
+            if self._run_hash:
+                self._run = aim.Run(
+                    self._run_hash,
+                    repo=self.repo,
+                    system_tracking_interval=self.system_tracking_interval,
+                )
+            else:
+                self._run = aim.Run(
+                    repo=self.repo,
+                    experiment=self.experiment_name,
+                    system_tracking_interval=self.system_tracking_interval,
+                    log_system_params=self.log_system_params,
+                )
+                self._run_hash = self._run.hash
+
+        if kwargs:
+            for key, value in kwargs.items():
+                self._run.set(key, value, strict=False)
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+        aim = import_aim()
+
+        self.step += 1
+        self.llm_starts += 1
+        self.starts += 1
+
+        resp = {"action": "on_llm_start"}
+        resp.update(self.get_custom_callback_meta())
+
+        prompts_res = deepcopy(prompts)
+
+        self._run.track(
+            [aim.Text(prompt) for prompt in prompts_res],
+            name="on_llm_start",
+            context=resp,
+        )
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        aim = import_aim()
+        self.step += 1
+        self.llm_ends += 1
+        self.ends += 1
+
+        resp = {"action": "on_llm_end"}
+        resp.update(self.get_custom_callback_meta())
+
+        response_res = deepcopy(response)
+
+        generated = [
+            aim.Text(generation.text)
+            for generations in response_res.generations
+            for generation in generations
+        ]
+        self._run.track(
+            generated,
+            name="on_llm_end",
+            context=resp,
+        )
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+        self.step += 1
+        self.llm_streams += 1
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        aim = import_aim()
+        self.step += 1
+        self.chain_starts += 1
+        self.starts += 1
+
+        resp = {"action": "on_chain_start"}
+        resp.update(self.get_custom_callback_meta())
+
+        inputs_res = deepcopy(inputs)
+
+        self._run.track(
+            aim.Text(inputs_res["input"]), name="on_chain_start", context=resp
+        )
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        aim = import_aim()
+        self.step += 1
+        self.chain_ends += 1
+        self.ends += 1
+
+        resp = {"action": "on_chain_end"}
+        resp.update(self.get_custom_callback_meta())
+
+        outputs_res = deepcopy(outputs)
+
+        self._run.track(
+            aim.Text(outputs_res["output"]), name="on_chain_end", context=resp
+        )
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        aim = import_aim()
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = {"action": "on_tool_start"}
+        resp.update(self.get_custom_callback_meta())
+
+        self._run.track(aim.Text(input_str), name="on_tool_start", context=resp)
+
+    def on_tool_end(self, output: Any, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        output = str(output)
+        aim = import_aim()
+        self.step += 1
+        self.tool_ends += 1
+        self.ends += 1
+
+        resp = {"action": "on_tool_end"}
+        resp.update(self.get_custom_callback_meta())
+
+        self._run.track(aim.Text(output), name="on_tool_end", context=resp)
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.step += 1
+        self.text_ctr += 1
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        aim = import_aim()
+        self.step += 1
+        self.agent_ends += 1
+        self.ends += 1
+
+        resp = {"action": "on_agent_finish"}
+        resp.update(self.get_custom_callback_meta())
+
+        finish_res = deepcopy(finish)
+
+        text = "OUTPUT:\n{}\n\nLOG:\n{}".format(
+            finish_res.return_values["output"], finish_res.log
+        )
+        self._run.track(aim.Text(text), name="on_agent_finish", context=resp)
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        aim = import_aim()
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = {
+            "action": "on_agent_action",
+            "tool": action.tool,
+        }
+        resp.update(self.get_custom_callback_meta())
+
+        action_res = deepcopy(action)
+
+        text = "TOOL INPUT:\n{}\n\nLOG:\n{}".format(
+            action_res.tool_input, action_res.log
+        )
+        self._run.track(aim.Text(text), name="on_agent_action", context=resp)
+
+    def flush_tracker(
+        self,
+        repo: Optional[str] = None,
+        experiment_name: Optional[str] = None,
+        system_tracking_interval: Optional[int] = 10,
+        log_system_params: bool = True,
+        langchain_asset: Any = None,
+        reset: bool = True,
+        finish: bool = False,
+    ) -> None:
+        """Flush the tracker and reset the session.
+
+        Args:
+            repo (:obj:`str`, optional): Aim repository path or Repo object to which
+                Run object is bound. If skipped, default Repo is used.
+            experiment_name (:obj:`str`, optional): Sets Run's `experiment` property.
+                'default' if not specified. Can be used later to query runs/sequences.
+            system_tracking_interval (:obj:`int`, optional): Sets the tracking interval
+                in seconds for system usage metrics (CPU, Memory, etc.). Set to `None`
+                 to disable system metrics tracking.
+            log_system_params (:obj:`bool`, optional): Enable/Disable logging of system
+                params such as installed packages, git info, environment variables, etc.
+            langchain_asset: The langchain asset to save.
+            reset: Whether to reset the session.
+            finish: Whether to finish the run.
+
+            Returns:
+                None
+        """
+
+        if langchain_asset:
+            try:
+                for key, value in langchain_asset.dict().items():
+                    self._run.set(key, value, strict=False)
+            except Exception:
+                pass
+
+        if finish or reset:
+            self._run.close()
+            self.reset_callback_meta()
+        if reset:
+            aim = import_aim()
+            self.repo = repo if repo else self.repo
+            self.experiment_name = (
+                experiment_name if experiment_name else self.experiment_name
+            )
+            self.system_tracking_interval = (
+                system_tracking_interval
+                if system_tracking_interval
+                else self.system_tracking_interval
+            )
+            self.log_system_params = (
+                log_system_params if log_system_params else self.log_system_params
+            )
+
+            self._run = aim.Run(
+                repo=self.repo,
+                experiment=self.experiment_name,
+                system_tracking_interval=self.system_tracking_interval,
+                log_system_params=self.log_system_params,
+            )
+            self._run_hash = self._run.hash
+            self.action_records = []

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/argilla_callback.py

@@ -0,0 +1,349 @@
+import os
+import warnings
+from typing import Any, Dict, List, Optional, cast
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+from packaging.version import parse
+
+
+class ArgillaCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs into Argilla.
+
+    Args:
+        dataset_name: name of the `FeedbackDataset` in Argilla. Note that it must
+            exist in advance. If you need help on how to create a `FeedbackDataset` in
+            Argilla, please visit
+            https://docs.argilla.io/en/latest/tutorials_and_integrations/integrations/use_argilla_callback_in_langchain.html.
+        workspace_name: name of the workspace in Argilla where the specified
+            `FeedbackDataset` lives in. Defaults to `None`, which means that the
+            default workspace will be used.
+        api_url: URL of the Argilla Server that we want to use, and where the
+            `FeedbackDataset` lives in. Defaults to `None`, which means that either
+            `ARGILLA_API_URL` environment variable or the default will be used.
+        api_key: API Key to connect to the Argilla Server. Defaults to `None`, which
+            means that either `ARGILLA_API_KEY` environment variable or the default
+            will be used.
+
+    Raises:
+        ImportError: if the `argilla` package is not installed.
+        ConnectionError: if the connection to Argilla fails.
+        FileNotFoundError: if the `FeedbackDataset` retrieval from Argilla fails.
+
+    Examples:
+        >>> from langchain_community.llms import OpenAI
+        >>> from langchain_community.callbacks import ArgillaCallbackHandler
+        >>> argilla_callback = ArgillaCallbackHandler(
+        ...     dataset_name="my-dataset",
+        ...     workspace_name="my-workspace",
+        ...     api_url="http://localhost:6900",
+        ...     api_key="argilla.apikey",
+        ... )
+        >>> llm = OpenAI(
+        ...     temperature=0,
+        ...     callbacks=[argilla_callback],
+        ...     verbose=True,
+        ...     openai_api_key="API_KEY_HERE",
+        ... )
+        >>> llm.generate([
+        ...     "What is the best NLP-annotation tool out there? (no bias at all)",
+        ... ])
+        "Argilla, no doubt about it."
+    """
+
+    REPO_URL: str = "https://github.com/argilla-io/argilla"
+    ISSUES_URL: str = f"{REPO_URL}/issues"
+    BLOG_URL: str = "https://docs.argilla.io/en/latest/tutorials_and_integrations/integrations/use_argilla_callback_in_langchain.html"
+
+    DEFAULT_API_URL: str = "http://localhost:6900"
+
+    def __init__(
+        self,
+        dataset_name: str,
+        workspace_name: Optional[str] = None,
+        api_url: Optional[str] = None,
+        api_key: Optional[str] = None,
+    ) -> None:
+        """Initializes the `ArgillaCallbackHandler`.
+
+        Args:
+            dataset_name: name of the `FeedbackDataset` in Argilla. Note that it must
+                exist in advance. If you need help on how to create a `FeedbackDataset`
+                in Argilla, please visit
+                https://docs.argilla.io/en/latest/tutorials_and_integrations/integrations/use_argilla_callback_in_langchain.html.
+            workspace_name: name of the workspace in Argilla where the specified
+                `FeedbackDataset` lives in. Defaults to `None`, which means that the
+                default workspace will be used.
+            api_url: URL of the Argilla Server that we want to use, and where the
+                `FeedbackDataset` lives in. Defaults to `None`, which means that either
+                `ARGILLA_API_URL` environment variable or the default will be used.
+            api_key: API Key to connect to the Argilla Server. Defaults to `None`, which
+                means that either `ARGILLA_API_KEY` environment variable or the default
+                will be used.
+
+        Raises:
+            ImportError: if the `argilla` package is not installed.
+            ConnectionError: if the connection to Argilla fails.
+            FileNotFoundError: if the `FeedbackDataset` retrieval from Argilla fails.
+        """
+
+        super().__init__()
+
+        # Import Argilla (not via `import_argilla` to keep hints in IDEs)
+        try:
+            import argilla as rg
+
+            self.ARGILLA_VERSION = rg.__version__
+        except ImportError:
+            raise ImportError(
+                "To use the Argilla callback manager you need to have the `argilla` "
+                "Python package installed. Please install it with `pip install argilla`"
+            )
+
+        # Check whether the Argilla version is compatible
+        if parse(self.ARGILLA_VERSION) < parse("1.8.0"):
+            raise ImportError(
+                f"The installed `argilla` version is {self.ARGILLA_VERSION} but "
+                "`ArgillaCallbackHandler` requires at least version 1.8.0. Please "
+                "upgrade `argilla` with `pip install --upgrade argilla`."
+            )
+
+        # Show a warning message if Argilla will assume the default values will be used
+        if api_url is None and os.getenv("ARGILLA_API_URL") is None:
+            warnings.warn(
+                (
+                    "Since `api_url` is None, and the env var `ARGILLA_API_URL` is not"
+                    f" set, it will default to `{self.DEFAULT_API_URL}`, which is the"
+                    " default API URL in Argilla Quickstart."
+                ),
+            )
+            api_url = self.DEFAULT_API_URL
+
+        if api_key is None and os.getenv("ARGILLA_API_KEY") is None:
+            self.DEFAULT_API_KEY = (
+                "admin.apikey"
+                if parse(self.ARGILLA_VERSION) < parse("1.11.0")
+                else "owner.apikey"
+            )
+
+            warnings.warn(
+                (
+                    "Since `api_key` is None, and the env var `ARGILLA_API_KEY` is not"
+                    f" set, it will default to `{self.DEFAULT_API_KEY}`, which is the"
+                    " default API key in Argilla Quickstart."
+                ),
+            )
+            api_key = self.DEFAULT_API_KEY
+
+        # Connect to Argilla with the provided credentials, if applicable
+        try:
+            rg.init(api_key=api_key, api_url=api_url)
+        except Exception as e:
+            raise ConnectionError(
+                f"Could not connect to Argilla with exception: '{e}'.\n"
+                "Please check your `api_key` and `api_url`, and make sure that "
+                "the Argilla server is up and running. If the problem persists "
+                f"please report it to {self.ISSUES_URL} as an `integration` issue."
+            ) from e
+
+        # Set the Argilla variables
+        self.dataset_name = dataset_name
+        self.workspace_name = workspace_name or rg.get_workspace()
+
+        # Retrieve the `FeedbackDataset` from Argilla (without existing records)
+        try:
+            extra_args = {}
+            if parse(self.ARGILLA_VERSION) < parse("1.14.0"):
+                warnings.warn(
+                    f"You have Argilla {self.ARGILLA_VERSION}, but Argilla 1.14.0 or"
+                    " higher is recommended.",
+                    UserWarning,
+                )
+                extra_args = {"with_records": False}
+            self.dataset = rg.FeedbackDataset.from_argilla(
+                name=self.dataset_name,
+                workspace=self.workspace_name,
+                **extra_args,
+            )
+        except Exception as e:
+            raise FileNotFoundError(
+                f"`FeedbackDataset` retrieval from Argilla failed with exception `{e}`."
+                f"\nPlease check that the dataset with name={self.dataset_name} in the"
+                f" workspace={self.workspace_name} exists in advance. If you need help"
+                " on how to create a `langchain`-compatible `FeedbackDataset` in"
+                f" Argilla, please visit {self.BLOG_URL}. If the problem persists"
+                f" please report it to {self.ISSUES_URL} as an `integration` issue."
+            ) from e
+
+        supported_fields = ["prompt", "response"]
+        if supported_fields != [field.name for field in self.dataset.fields]:
+            raise ValueError(
+                f"`FeedbackDataset` with name={self.dataset_name} in the workspace="
+                f"{self.workspace_name} had fields that are not supported yet for the"
+                f"`langchain` integration. Supported fields are: {supported_fields},"
+                f" and the current `FeedbackDataset` fields are {[field.name for field in self.dataset.fields]}."  # noqa: E501
+                " For more information on how to create a `langchain`-compatible"
+                f" `FeedbackDataset` in Argilla, please visit {self.BLOG_URL}."
+            )
+
+        self.prompts: Dict[str, List[str]] = {}
+
+        warnings.warn(
+            (
+                "The `ArgillaCallbackHandler` is currently in beta and is subject to"
+                " change based on updates to `langchain`. Please report any issues to"
+                f" {self.ISSUES_URL} as an `integration` issue."
+            ),
+        )
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Save the prompts in memory when an LLM starts."""
+        self.prompts.update({str(kwargs["parent_run_id"] or kwargs["run_id"]): prompts})
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Do nothing when a new token is generated."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Log records to Argilla when an LLM ends."""
+        # Do nothing if there's a parent_run_id, since we will log the records when
+        # the chain ends
+        if kwargs["parent_run_id"]:
+            return
+
+        # Creates the records and adds them to the `FeedbackDataset`
+        prompts = self.prompts[str(kwargs["run_id"])]
+        for prompt, generations in zip(prompts, response.generations):
+            self.dataset.add_records(
+                records=[
+                    {
+                        "fields": {
+                            "prompt": prompt,
+                            "response": generation.text.strip(),
+                        },
+                    }
+                    for generation in generations
+                ]
+            )
+
+        # Pop current run from `self.runs`
+        self.prompts.pop(str(kwargs["run_id"]))
+
+        if parse(self.ARGILLA_VERSION) < parse("1.14.0"):
+            # Push the records to Argilla
+            self.dataset.push_to_argilla()
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM outputs an error."""
+        pass
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """If the key `input` is in `inputs`, then save it in `self.prompts` using
+        either the `parent_run_id` or the `run_id` as the key. This is done so that
+        we don't log the same input prompt twice, once when the LLM starts and once
+        when the chain starts.
+        """
+        if "input" in inputs:
+            self.prompts.update(
+                {
+                    str(kwargs["parent_run_id"] or kwargs["run_id"]): (
+                        inputs["input"]
+                        if isinstance(inputs["input"], list)
+                        else [inputs["input"]]
+                    )
+                }
+            )
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """If either the `parent_run_id` or the `run_id` is in `self.prompts`, then
+        log the outputs to Argilla, and pop the run from `self.prompts`. The behavior
+        differs if the output is a list or not.
+        """
+        if not any(
+            key in self.prompts
+            for key in [str(kwargs["parent_run_id"]), str(kwargs["run_id"])]
+        ):
+            return
+        prompts: List = self.prompts.get(str(kwargs["parent_run_id"])) or cast(
+            List, self.prompts.get(str(kwargs["run_id"]), [])
+        )
+        for chain_output_key, chain_output_val in outputs.items():
+            if isinstance(chain_output_val, list):
+                # Creates the records and adds them to the `FeedbackDataset`
+                self.dataset.add_records(
+                    records=[
+                        {
+                            "fields": {
+                                "prompt": prompt,
+                                "response": output["text"].strip(),
+                            },
+                        }
+                        for prompt, output in zip(prompts, chain_output_val)
+                    ]
+                )
+            else:
+                # Creates the records and adds them to the `FeedbackDataset`
+                self.dataset.add_records(
+                    records=[
+                        {
+                            "fields": {
+                                "prompt": " ".join(prompts),
+                                "response": chain_output_val.strip(),
+                            },
+                        }
+                    ]
+                )
+
+        # Pop current run from `self.runs`
+        if str(kwargs["parent_run_id"]) in self.prompts:
+            self.prompts.pop(str(kwargs["parent_run_id"]))
+        if str(kwargs["run_id"]) in self.prompts:
+            self.prompts.pop(str(kwargs["run_id"]))
+
+        if parse(self.ARGILLA_VERSION) < parse("1.14.0"):
+            # Push the records to Argilla
+            self.dataset.push_to_argilla()
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM chain outputs an error."""
+        pass
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool starts."""
+        pass
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing when agent takes a specific action."""
+        pass
+
+    def on_tool_end(
+        self,
+        output: Any,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool ends."""
+        pass
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when tool outputs an error."""
+        pass
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """Do nothing"""
+        pass
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Do nothing"""
+        pass

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/arize_callback.py

@@ -0,0 +1,213 @@
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+
+from langchain_community.callbacks.utils import import_pandas
+
+
+class ArizeCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs to Arize."""
+
+    def __init__(
+        self,
+        model_id: Optional[str] = None,
+        model_version: Optional[str] = None,
+        SPACE_KEY: Optional[str] = None,
+        API_KEY: Optional[str] = None,
+    ) -> None:
+        """Initialize callback handler."""
+
+        super().__init__()
+        self.model_id = model_id
+        self.model_version = model_version
+        self.space_key = SPACE_KEY
+        self.api_key = API_KEY
+        self.prompt_records: List[str] = []
+        self.response_records: List[str] = []
+        self.prediction_ids: List[str] = []
+        self.pred_timestamps: List[int] = []
+        self.response_embeddings: List[float] = []
+        self.prompt_embeddings: List[float] = []
+        self.prompt_tokens = 0
+        self.completion_tokens = 0
+        self.total_tokens = 0
+        self.step = 0
+
+        from arize.pandas.embeddings import EmbeddingGenerator, UseCases
+        from arize.pandas.logger import Client
+
+        self.generator = EmbeddingGenerator.from_use_case(
+            use_case=UseCases.NLP.SEQUENCE_CLASSIFICATION,
+            model_name="distilbert-base-uncased",
+            tokenizer_max_length=512,
+            batch_size=256,
+        )
+        self.arize_client = Client(space_key=SPACE_KEY, api_key=API_KEY)
+        if SPACE_KEY == "SPACE_KEY" or API_KEY == "API_KEY":
+            raise ValueError("❌ CHANGE SPACE AND API KEYS")
+        else:
+            print("✅ Arize client setup done! Now you can start using Arize!")  # noqa: T201
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        for prompt in prompts:
+            self.prompt_records.append(prompt.replace("\n", ""))
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        pd = import_pandas()
+        from arize.utils.types import (
+            EmbeddingColumnNames,
+            Environments,
+            ModelTypes,
+            Schema,
+        )
+
+        # Safe check if 'llm_output' and 'token_usage' exist
+        if response.llm_output and "token_usage" in response.llm_output:
+            self.prompt_tokens = response.llm_output["token_usage"].get(
+                "prompt_tokens", 0
+            )
+            self.total_tokens = response.llm_output["token_usage"].get(
+                "total_tokens", 0
+            )
+            self.completion_tokens = response.llm_output["token_usage"].get(
+                "completion_tokens", 0
+            )
+        else:
+            self.prompt_tokens = self.total_tokens = self.completion_tokens = (
+                0  # assign default value
+            )
+
+        for generations in response.generations:
+            for generation in generations:
+                prompt = self.prompt_records[self.step]
+                self.step = self.step + 1
+                prompt_embedding = pd.Series(
+                    self.generator.generate_embeddings(
+                        text_col=pd.Series(prompt.replace("\n", " "))
+                    ).reset_index(drop=True)
+                )
+
+                # Assigning text to response_text instead of response
+                response_text = generation.text.replace("\n", " ")
+                response_embedding = pd.Series(
+                    self.generator.generate_embeddings(
+                        text_col=pd.Series(generation.text.replace("\n", " "))
+                    ).reset_index(drop=True)
+                )
+                pred_timestamp = datetime.now().timestamp()
+
+                # Define the columns and data
+                columns = [
+                    "prediction_ts",
+                    "response",
+                    "prompt",
+                    "response_vector",
+                    "prompt_vector",
+                    "prompt_token",
+                    "completion_token",
+                    "total_token",
+                ]
+                data = [
+                    [
+                        pred_timestamp,
+                        response_text,
+                        prompt,
+                        response_embedding[0],
+                        prompt_embedding[0],
+                        self.prompt_tokens,
+                        self.total_tokens,
+                        self.completion_tokens,
+                    ]
+                ]
+
+                # Create the DataFrame
+                df = pd.DataFrame(data, columns=columns)
+
+                # Declare prompt and response columns
+                prompt_columns = EmbeddingColumnNames(
+                    vector_column_name="prompt_vector", data_column_name="prompt"
+                )
+
+                response_columns = EmbeddingColumnNames(
+                    vector_column_name="response_vector", data_column_name="response"
+                )
+
+                schema = Schema(
+                    timestamp_column_name="prediction_ts",
+                    tag_column_names=[
+                        "prompt_token",
+                        "completion_token",
+                        "total_token",
+                    ],
+                    prompt_column_names=prompt_columns,
+                    response_column_names=response_columns,
+                )
+
+                response_from_arize = self.arize_client.log(
+                    dataframe=df,
+                    schema=schema,
+                    model_id=self.model_id,
+                    model_version=self.model_version,
+                    model_type=ModelTypes.GENERATIVE_LLM,
+                    environment=Environments.PRODUCTION,
+                )
+                if response_from_arize.status_code == 200:
+                    print("✅ Successfully logged data to Arize!")  # noqa: T201
+                else:
+                    print(f'❌ Logging failed "{response_from_arize.text}"')  # noqa: T201
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        pass
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        pass
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing."""
+        pass
+
+    def on_tool_end(
+        self,
+        output: Any,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        pass
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        pass
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        pass
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        pass

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/arthur_callback.py

@@ -0,0 +1,297 @@
+"""ArthurAI's Callback Handler."""
+
+from __future__ import annotations
+
+import os
+import uuid
+from collections import defaultdict
+from datetime import datetime
+from time import time
+from typing import TYPE_CHECKING, Any, DefaultDict, Dict, List, Optional
+
+import numpy as np
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+
+if TYPE_CHECKING:
+    import arthurai
+    from arthurai.core.models import ArthurModel
+
+PROMPT_TOKENS = "prompt_tokens"
+COMPLETION_TOKENS = "completion_tokens"
+TOKEN_USAGE = "token_usage"
+FINISH_REASON = "finish_reason"
+DURATION = "duration"
+
+
+def _lazy_load_arthur() -> arthurai:
+    """Lazy load Arthur."""
+    try:
+        import arthurai
+    except ImportError as e:
+        raise ImportError(
+            "To use the ArthurCallbackHandler you need the"
+            " `arthurai` package. Please install it with"
+            " `pip install arthurai`.",
+            e,
+        )
+
+    return arthurai
+
+
+class ArthurCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs to Arthur platform.
+
+    Arthur helps enterprise teams optimize model operations
+    and performance at scale. The Arthur API tracks model
+    performance, explainability, and fairness across tabular,
+    NLP, and CV models. Our API is model- and platform-agnostic,
+    and continuously scales with complex and dynamic enterprise needs.
+    To learn more about Arthur, visit our website at
+    https://www.arthur.ai/ or read the Arthur docs at
+    https://docs.arthur.ai/
+    """
+
+    def __init__(
+        self,
+        arthur_model: ArthurModel,
+    ) -> None:
+        """Initialize callback handler."""
+        super().__init__()
+        arthurai = _lazy_load_arthur()
+        Stage = arthurai.common.constants.Stage
+        ValueType = arthurai.common.constants.ValueType
+        self.arthur_model = arthur_model
+        # save the attributes of this model to be used when preparing
+        # inferences to log to Arthur in on_llm_end()
+        self.attr_names = set([a.name for a in self.arthur_model.get_attributes()])
+        self.input_attr = [
+            x
+            for x in self.arthur_model.get_attributes()
+            if x.stage == Stage.ModelPipelineInput
+            and x.value_type == ValueType.Unstructured_Text
+        ][0].name
+        self.output_attr = [
+            x
+            for x in self.arthur_model.get_attributes()
+            if x.stage == Stage.PredictedValue
+            and x.value_type == ValueType.Unstructured_Text
+        ][0].name
+        self.token_likelihood_attr = None
+        if (
+            len(
+                [
+                    x
+                    for x in self.arthur_model.get_attributes()
+                    if x.value_type == ValueType.TokenLikelihoods
+                ]
+            )
+            > 0
+        ):
+            self.token_likelihood_attr = [
+                x
+                for x in self.arthur_model.get_attributes()
+                if x.value_type == ValueType.TokenLikelihoods
+            ][0].name
+
+        self.run_map: DefaultDict[str, Any] = defaultdict(dict)
+
+    @classmethod
+    def from_credentials(
+        cls,
+        model_id: str,
+        arthur_url: Optional[str] = "https://app.arthur.ai",
+        arthur_login: Optional[str] = None,
+        arthur_password: Optional[str] = None,
+    ) -> ArthurCallbackHandler:
+        """Initialize callback handler from Arthur credentials.
+
+        Args:
+            model_id (str): The ID of the arthur model to log to.
+            arthur_url (str, optional): The URL of the Arthur instance to log to.
+                Defaults to "https://app.arthur.ai".
+            arthur_login (str, optional): The login to use to connect to Arthur.
+                Defaults to None.
+            arthur_password (str, optional): The password to use to connect to
+                Arthur. Defaults to None.
+
+        Returns:
+            ArthurCallbackHandler: The initialized callback handler.
+        """
+        arthurai = _lazy_load_arthur()
+        ArthurAI = arthurai.ArthurAI
+        ResponseClientError = arthurai.common.exceptions.ResponseClientError
+
+        # connect to Arthur
+        if arthur_login is None:
+            try:
+                arthur_api_key = os.environ["ARTHUR_API_KEY"]
+            except KeyError:
+                raise ValueError(
+                    "No Arthur authentication provided. Either give"
+                    " a login to the ArthurCallbackHandler"
+                    " or set an ARTHUR_API_KEY as an environment variable."
+                )
+            arthur = ArthurAI(url=arthur_url, access_key=arthur_api_key)
+        else:
+            if arthur_password is None:
+                arthur = ArthurAI(url=arthur_url, login=arthur_login)
+            else:
+                arthur = ArthurAI(
+                    url=arthur_url, login=arthur_login, password=arthur_password
+                )
+        # get model from Arthur by the provided model ID
+        try:
+            arthur_model = arthur.get_model(model_id)
+        except ResponseClientError:
+            raise ValueError(
+                f"Was unable to retrieve model with id {model_id} from Arthur."
+                " Make sure the ID corresponds to a model that is currently"
+                " registered with your Arthur account."
+            )
+        return cls(arthur_model)
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """On LLM start, save the input prompts"""
+        run_id = kwargs["run_id"]
+        self.run_map[run_id]["input_texts"] = prompts
+        self.run_map[run_id]["start_time"] = time()
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """On LLM end, send data to Arthur."""
+        try:
+            import pytz
+        except ImportError as e:
+            raise ImportError(
+                "Could not import pytz. Please install it with 'pip install pytz'."
+            ) from e
+
+        run_id = kwargs["run_id"]
+
+        # get the run params from this run ID,
+        # or raise an error if this run ID has no corresponding metadata in self.run_map
+        try:
+            run_map_data = self.run_map[run_id]
+        except KeyError as e:
+            raise KeyError(
+                "This function has been called with a run_id"
+                " that was never registered in on_llm_start()."
+                " Restart and try running the LLM again"
+            ) from e
+
+        # mark the duration time between on_llm_start() and on_llm_end()
+        time_from_start_to_end = time() - run_map_data["start_time"]
+
+        # create inferences to log to Arthur
+        inferences = []
+        for i, generations in enumerate(response.generations):
+            for generation in generations:
+                inference = {
+                    "partner_inference_id": str(uuid.uuid4()),
+                    "inference_timestamp": datetime.now(tz=pytz.UTC),
+                    self.input_attr: run_map_data["input_texts"][i],
+                    self.output_attr: generation.text,
+                }
+
+                if generation.generation_info is not None:
+                    # add finish reason to the inference
+                    # if generation info contains a finish reason and
+                    # if the ArthurModel was registered to monitor finish_reason
+                    if (
+                        FINISH_REASON in generation.generation_info
+                        and FINISH_REASON in self.attr_names
+                    ):
+                        inference[FINISH_REASON] = generation.generation_info[
+                            FINISH_REASON
+                        ]
+
+                    # add token likelihoods data to the inference if the ArthurModel
+                    # was registered to monitor token likelihoods
+                    logprobs_data = generation.generation_info["logprobs"]
+                    if (
+                        logprobs_data is not None
+                        and self.token_likelihood_attr is not None
+                    ):
+                        logprobs = logprobs_data["top_logprobs"]
+                        likelihoods = [
+                            {k: np.exp(v) for k, v in logprobs[i].items()}
+                            for i in range(len(logprobs))
+                        ]
+                        inference[self.token_likelihood_attr] = likelihoods
+
+                # add token usage counts to the inference if the
+                # ArthurModel was registered to monitor token usage
+                if (
+                    isinstance(response.llm_output, dict)
+                    and TOKEN_USAGE in response.llm_output
+                ):
+                    token_usage = response.llm_output[TOKEN_USAGE]
+                    if (
+                        PROMPT_TOKENS in token_usage
+                        and PROMPT_TOKENS in self.attr_names
+                    ):
+                        inference[PROMPT_TOKENS] = token_usage[PROMPT_TOKENS]
+                    if (
+                        COMPLETION_TOKENS in token_usage
+                        and COMPLETION_TOKENS in self.attr_names
+                    ):
+                        inference[COMPLETION_TOKENS] = token_usage[COMPLETION_TOKENS]
+
+                # add inference duration to the inference if the ArthurModel
+                # was registered to monitor inference duration
+                if DURATION in self.attr_names:
+                    inference[DURATION] = time_from_start_to_end
+
+                inferences.append(inference)
+
+        # send inferences to arthur
+        self.arthur_model.send_inferences(inferences)
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """On chain start, do nothing."""
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """On chain end, do nothing."""
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM outputs an error."""
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """On new token, pass."""
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM chain outputs an error."""
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool starts."""
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing when agent takes a specific action."""
+
+    def on_tool_end(
+        self,
+        output: Any,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool ends."""
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when tool outputs an error."""
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """Do nothing"""
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Do nothing"""

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/bedrock_anthropic_callback.py

@@ -0,0 +1,135 @@
+import threading
+from typing import Any, Dict, List, Union
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+
+MODEL_COST_PER_1K_INPUT_TOKENS = {
+    "anthropic.claude-instant-v1": 0.0008,
+    "anthropic.claude-v2": 0.008,
+    "anthropic.claude-v2:1": 0.008,
+    "anthropic.claude-3-sonnet-20240229-v1:0": 0.003,
+    "anthropic.claude-3-5-sonnet-20240620-v1:0": 0.003,
+    "anthropic.claude-3-5-sonnet-20241022-v2:0": 0.003,
+    "anthropic.claude-3-7-sonnet-20250219-v1:0": 0.003,
+    "anthropic.claude-sonnet-4-20250514-v1:0": 0.003,
+    "anthropic.claude-3-haiku-20240307-v1:0": 0.00025,
+    "anthropic.claude-3-opus-20240229-v1:0": 0.015,
+    "anthropic.claude-opus-4-20250514-v1:0": 0.015,
+    "anthropic.claude-3-5-haiku-20241022-v1:0": 0.0008,
+}
+
+MODEL_COST_PER_1K_OUTPUT_TOKENS = {
+    "anthropic.claude-instant-v1": 0.0024,
+    "anthropic.claude-v2": 0.024,
+    "anthropic.claude-v2:1": 0.024,
+    "anthropic.claude-3-sonnet-20240229-v1:0": 0.015,
+    "anthropic.claude-3-5-sonnet-20240620-v1:0": 0.015,
+    "anthropic.claude-3-5-sonnet-20241022-v2:0": 0.015,
+    "anthropic.claude-3-7-sonnet-20250219-v1:0": 0.015,
+    "anthropic.claude-sonnet-4-20250514-v1:0": 0.015,
+    "anthropic.claude-3-haiku-20240307-v1:0": 0.00125,
+    "anthropic.claude-3-opus-20240229-v1:0": 0.075,
+    "anthropic.claude-opus-4-20250514-v1:0": 0.075,
+    "anthropic.claude-3-5-haiku-20241022-v1:0": 0.004,
+}
+
+
+def _get_anthropic_claude_token_cost(
+    prompt_tokens: int, completion_tokens: int, model_id: Union[str, None]
+) -> float:
+    if model_id:
+        # The model ID can be a cross-region (system-defined) inference profile ID,
+        # which has a prefix indicating the region (e.g., 'us', 'eu') but
+        # shares the same token costs as the "base model".
+        # By extracting the "base model ID", by taking the last two segments
+        # of the model ID, we can map cross-region inference profile IDs to
+        # their corresponding cost entries.
+        base_model_id = model_id.split(".")[-2] + "." + model_id.split(".")[-1]
+    else:
+        base_model_id = None
+    """Get the cost of tokens for the Claude model."""
+    if base_model_id not in MODEL_COST_PER_1K_INPUT_TOKENS:
+        raise ValueError(
+            f"Unknown model: {model_id}. Please provide a valid Anthropic model name."
+            "Known models are: " + ", ".join(MODEL_COST_PER_1K_INPUT_TOKENS.keys())
+        )
+    return (prompt_tokens / 1000) * MODEL_COST_PER_1K_INPUT_TOKENS[base_model_id] + (
+        completion_tokens / 1000
+    ) * MODEL_COST_PER_1K_OUTPUT_TOKENS[base_model_id]
+
+
+class BedrockAnthropicTokenUsageCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that tracks bedrock anthropic info."""
+
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    completion_tokens: int = 0
+    successful_requests: int = 0
+    total_cost: float = 0.0
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._lock = threading.Lock()
+
+    def __repr__(self) -> str:
+        return (
+            f"Tokens Used: {self.total_tokens}\n"
+            f"\tPrompt Tokens: {self.prompt_tokens}\n"
+            f"\tCompletion Tokens: {self.completion_tokens}\n"
+            f"Successful Requests: {self.successful_requests}\n"
+            f"Total Cost (USD): ${self.total_cost}"
+        )
+
+    @property
+    def always_verbose(self) -> bool:
+        """Whether to call verbose callbacks even if verbose is False."""
+        return True
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Print out the prompts."""
+        pass
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Print out the token."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Collect token usage."""
+        if response.llm_output is None:
+            return None
+
+        if "usage" not in response.llm_output:
+            with self._lock:
+                self.successful_requests += 1
+            return None
+
+        # compute tokens and cost for this request
+        token_usage = response.llm_output["usage"]
+        completion_tokens = token_usage.get("completion_tokens", 0)
+        prompt_tokens = token_usage.get("prompt_tokens", 0)
+        total_tokens = token_usage.get("total_tokens", 0)
+        model_id = response.llm_output.get("model_id", None)
+        total_cost = _get_anthropic_claude_token_cost(
+            prompt_tokens=prompt_tokens,
+            completion_tokens=completion_tokens,
+            model_id=model_id,
+        )
+
+        # update shared state behind lock
+        with self._lock:
+            self.total_cost += total_cost
+            self.total_tokens += total_tokens
+            self.prompt_tokens += prompt_tokens
+            self.completion_tokens += completion_tokens
+            self.successful_requests += 1
+
+    def __copy__(self) -> "BedrockAnthropicTokenUsageCallbackHandler":
+        """Return a copy of the callback handler."""
+        return self
+
+    def __deepcopy__(self, memo: Any) -> "BedrockAnthropicTokenUsageCallbackHandler":
+        """Return a deep copy of the callback handler."""
+        return self

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/clearml_callback.py

@@ -0,0 +1,518 @@
+from __future__ import annotations
+
+import tempfile
+from copy import deepcopy
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Sequence
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+from langchain_community.callbacks.utils import (
+    BaseMetadataCallbackHandler,
+    flatten_dict,
+    hash_string,
+    import_pandas,
+    import_spacy,
+    import_textstat,
+    load_json,
+)
+
+if TYPE_CHECKING:
+    import pandas as pd
+
+
+def import_clearml() -> Any:
+    """Import the clearml python package and raise an error if it is not installed."""
+    return guard_import("clearml")
+
+
+class ClearMLCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """Callback Handler that logs to ClearML.
+
+    Parameters:
+        job_type (str): The type of clearml task such as "inference", "testing" or "qc"
+        project_name (str): The clearml project name
+        tags (list): Tags to add to the task
+        task_name (str): Name of the clearml task
+        visualize (bool): Whether to visualize the run.
+        complexity_metrics (bool): Whether to log complexity metrics
+        stream_logs (bool): Whether to stream callback actions to ClearML
+
+    This handler will utilize the associated callback method and formats
+    the input of each callback function with metadata regarding the state of LLM run,
+    and adds the response to the list of records for both the {method}_records and
+    action. It then logs the response to the ClearML console.
+    """
+
+    def __init__(
+        self,
+        task_type: Optional[str] = "inference",
+        project_name: Optional[str] = "langchain_callback_demo",
+        tags: Optional[Sequence] = None,
+        task_name: Optional[str] = None,
+        visualize: bool = False,
+        complexity_metrics: bool = False,
+        stream_logs: bool = False,
+    ) -> None:
+        """Initialize callback handler."""
+
+        clearml = import_clearml()
+        spacy = import_spacy()
+        super().__init__()
+
+        self.task_type = task_type
+        self.project_name = project_name
+        self.tags = tags
+        self.task_name = task_name
+        self.visualize = visualize
+        self.complexity_metrics = complexity_metrics
+        self.stream_logs = stream_logs
+
+        self.temp_dir = tempfile.TemporaryDirectory()
+
+        # Check if ClearML task already exists (e.g. in pipeline)
+        if clearml.Task.current_task():
+            self.task = clearml.Task.current_task()
+        else:
+            self.task = clearml.Task.init(
+                task_type=self.task_type,
+                project_name=self.project_name,
+                tags=self.tags,
+                task_name=self.task_name,
+                output_uri=True,
+            )
+        self.logger = self.task.get_logger()
+        warning = (
+            "The clearml callback is currently in beta and is subject to change "
+            "based on updates to `langchain`. Please report any issues to "
+            "https://github.com/allegroai/clearml/issues with the tag `langchain`."
+        )
+        self.logger.report_text(warning, level=30, print_console=True)
+        self.callback_columns: list = []
+        self.action_records: list = []
+        self.complexity_metrics = complexity_metrics
+        self.visualize = visualize
+        self.nlp = spacy.load("en_core_web_sm")
+
+    def _init_resp(self) -> Dict:
+        return {k: None for k in self.callback_columns}
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+        self.step += 1
+        self.llm_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        for prompt in prompts:
+            prompt_resp = deepcopy(resp)
+            prompt_resp["prompts"] = prompt
+            self.on_llm_start_records.append(prompt_resp)
+            self.action_records.append(prompt_resp)
+            if self.stream_logs:
+                self.logger.report_text(prompt_resp)
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+        self.step += 1
+        self.llm_streams += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_new_token", "token": token})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_llm_token_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.step += 1
+        self.llm_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_end"})
+        resp.update(flatten_dict(response.llm_output or {}))
+        resp.update(self.get_custom_callback_meta())
+
+        for generations in response.generations:
+            for generation in generations:
+                generation_resp = deepcopy(resp)
+                generation_resp.update(flatten_dict(generation.dict()))
+                generation_resp.update(self.analyze_text(generation.text))
+                self.on_llm_end_records.append(generation_resp)
+                self.action_records.append(generation_resp)
+                if self.stream_logs:
+                    self.logger.report_text(generation_resp)
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.step += 1
+        self.chain_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        chain_input = inputs.get("input", inputs.get("human_input"))
+
+        if isinstance(chain_input, str):
+            input_resp = deepcopy(resp)
+            input_resp["input"] = chain_input
+            self.on_chain_start_records.append(input_resp)
+            self.action_records.append(input_resp)
+            if self.stream_logs:
+                self.logger.report_text(input_resp)
+        elif isinstance(chain_input, list):
+            for inp in chain_input:
+                input_resp = deepcopy(resp)
+                input_resp.update(inp)
+                self.on_chain_start_records.append(input_resp)
+                self.action_records.append(input_resp)
+                if self.stream_logs:
+                    self.logger.report_text(input_resp)
+        else:
+            raise ValueError("Unexpected data format provided!")
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        self.step += 1
+        self.chain_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update(
+            {
+                "action": "on_chain_end",
+                "outputs": outputs.get("output", outputs.get("text")),
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_chain_end_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_tool_start", "input_str": input_str})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_tool_start_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def on_tool_end(self, output: Any, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        output = str(output)
+        self.step += 1
+        self.tool_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_tool_end", "output": output})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_tool_end_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.step += 1
+        self.text_ctr += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_text", "text": text})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_text_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.step += 1
+        self.agent_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update(
+            {
+                "action": "on_agent_finish",
+                "output": finish.return_values["output"],
+                "log": finish.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_agent_finish_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update(
+            {
+                "action": "on_agent_action",
+                "tool": action.tool,
+                "tool_input": action.tool_input,
+                "log": action.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+        self.on_agent_action_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.logger.report_text(resp)
+
+    def analyze_text(self, text: str) -> dict:
+        """Analyze text using textstat and spacy.
+
+        Parameters:
+            text (str): The text to analyze.
+
+        Returns:
+            `dict` containing the complexity metrics.
+        """
+        resp = {}
+        textstat = import_textstat()
+        spacy = import_spacy()
+        if self.complexity_metrics:
+            text_complexity_metrics = {
+                "flesch_reading_ease": textstat.flesch_reading_ease(text),
+                "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
+                "smog_index": textstat.smog_index(text),
+                "coleman_liau_index": textstat.coleman_liau_index(text),
+                "automated_readability_index": textstat.automated_readability_index(
+                    text
+                ),
+                "dale_chall_readability_score": textstat.dale_chall_readability_score(
+                    text
+                ),
+                "difficult_words": textstat.difficult_words(text),
+                "linsear_write_formula": textstat.linsear_write_formula(text),
+                "gunning_fog": textstat.gunning_fog(text),
+                "text_standard": textstat.text_standard(text),
+                "fernandez_huerta": textstat.fernandez_huerta(text),
+                "szigriszt_pazos": textstat.szigriszt_pazos(text),
+                "gutierrez_polini": textstat.gutierrez_polini(text),
+                "crawford": textstat.crawford(text),
+                "gulpease_index": textstat.gulpease_index(text),
+                "osman": textstat.osman(text),
+            }
+            resp.update(text_complexity_metrics)
+
+        if self.visualize and self.nlp and self.temp_dir.name is not None:
+            doc = self.nlp(text)
+
+            dep_out = spacy.displacy.render(doc, style="dep", jupyter=False, page=True)
+            dep_output_path = Path(
+                self.temp_dir.name, hash_string(f"dep-{text}") + ".html"
+            )
+            dep_output_path.open("w", encoding="utf-8").write(dep_out)
+
+            ent_out = spacy.displacy.render(doc, style="ent", jupyter=False, page=True)
+            ent_output_path = Path(
+                self.temp_dir.name, hash_string(f"ent-{text}") + ".html"
+            )
+            ent_output_path.open("w", encoding="utf-8").write(ent_out)
+
+            self.logger.report_media(
+                "Dependencies Plot", text, local_path=dep_output_path
+            )
+            self.logger.report_media("Entities Plot", text, local_path=ent_output_path)
+
+        return resp
+
+    @staticmethod
+    def _build_llm_df(
+        base_df: pd.DataFrame, base_df_fields: Sequence, rename_map: Mapping
+    ) -> pd.DataFrame:
+        base_df_fields = [field for field in base_df_fields if field in base_df]
+        rename_map = {
+            map_entry_k: map_entry_v
+            for map_entry_k, map_entry_v in rename_map.items()
+            if map_entry_k in base_df_fields
+        }
+        llm_df = base_df[base_df_fields].dropna(axis=1)
+        if rename_map:
+            llm_df = llm_df.rename(rename_map, axis=1)
+        return llm_df
+
+    def _create_session_analysis_df(self) -> Any:
+        """Create a dataframe with all the information from the session."""
+        pd = import_pandas()
+        on_llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
+
+        llm_input_prompts_df = ClearMLCallbackHandler._build_llm_df(
+            base_df=on_llm_end_records_df,
+            base_df_fields=["step", "prompts"]
+            + (["name"] if "name" in on_llm_end_records_df else ["id"]),
+            rename_map={"step": "prompt_step"},
+        )
+        complexity_metrics_columns = []
+        visualizations_columns: List = []
+
+        if self.complexity_metrics:
+            complexity_metrics_columns = [
+                "flesch_reading_ease",
+                "flesch_kincaid_grade",
+                "smog_index",
+                "coleman_liau_index",
+                "automated_readability_index",
+                "dale_chall_readability_score",
+                "difficult_words",
+                "linsear_write_formula",
+                "gunning_fog",
+                "text_standard",
+                "fernandez_huerta",
+                "szigriszt_pazos",
+                "gutierrez_polini",
+                "crawford",
+                "gulpease_index",
+                "osman",
+            ]
+
+        llm_outputs_df = ClearMLCallbackHandler._build_llm_df(
+            on_llm_end_records_df,
+            [
+                "step",
+                "text",
+                "token_usage_total_tokens",
+                "token_usage_prompt_tokens",
+                "token_usage_completion_tokens",
+            ]
+            + complexity_metrics_columns
+            + visualizations_columns,
+            {"step": "output_step", "text": "output"},
+        )
+        session_analysis_df = pd.concat([llm_input_prompts_df, llm_outputs_df], axis=1)
+        return session_analysis_df
+
+    def flush_tracker(
+        self,
+        name: Optional[str] = None,
+        langchain_asset: Any = None,
+        finish: bool = False,
+    ) -> None:
+        """Flush the tracker and setup the session.
+
+        Everything after this will be a new table.
+
+        Args:
+            name: Name of the performed session so far so it is identifiable
+            langchain_asset: The langchain asset to save.
+            finish: Whether to finish the run.
+
+            Returns:
+                None
+        """
+        pd = import_pandas()
+        clearml = import_clearml()
+
+        # Log the action records
+        self.logger.report_table(
+            "Action Records", name, table_plot=pd.DataFrame(self.action_records)
+        )
+
+        # Session analysis
+        session_analysis_df = self._create_session_analysis_df()
+        self.logger.report_table(
+            "Session Analysis", name, table_plot=session_analysis_df
+        )
+
+        if self.stream_logs:
+            self.logger.report_text(
+                {
+                    "action_records": pd.DataFrame(self.action_records),
+                    "session_analysis": session_analysis_df,
+                }
+            )
+
+        if langchain_asset:
+            langchain_asset_path = Path(self.temp_dir.name, "model.json")
+            try:
+                langchain_asset.save(langchain_asset_path)
+                # Create output model and connect it to the task
+                output_model = clearml.OutputModel(
+                    task=self.task, config_text=load_json(langchain_asset_path)
+                )
+                output_model.update_weights(
+                    weights_filename=str(langchain_asset_path),
+                    auto_delete_file=False,
+                    target_filename=name,
+                )
+            except ValueError:
+                langchain_asset.save_agent(langchain_asset_path)
+                output_model = clearml.OutputModel(
+                    task=self.task, config_text=load_json(langchain_asset_path)
+                )
+                output_model.update_weights(
+                    weights_filename=str(langchain_asset_path),
+                    auto_delete_file=False,
+                    target_filename=name,
+                )
+            except NotImplementedError as e:
+                print("Could not save model.")  # noqa: T201
+                print(repr(e))  # noqa: T201
+                pass
+
+        # Cleanup after adding everything to ClearML
+        self.task.flush(wait_for_uploads=True)
+        self.temp_dir.cleanup()
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.reset_callback_meta()
+
+        if finish:
+            self.task.close()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/comet_ml_callback.py

@@ -0,0 +1,639 @@
+import tempfile
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Sequence
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import Generation, LLMResult
+from langchain_core.utils import guard_import
+
+import langchain_community
+from langchain_community.callbacks.utils import (
+    BaseMetadataCallbackHandler,
+    flatten_dict,
+    import_pandas,
+    import_spacy,
+    import_textstat,
+)
+
+LANGCHAIN_MODEL_NAME = "langchain-model"
+
+
+def import_comet_ml() -> Any:
+    """Import comet_ml and raise an error if it is not installed."""
+    return guard_import("comet_ml")
+
+
+def _get_experiment(
+    workspace: Optional[str] = None, project_name: Optional[str] = None
+) -> Any:
+    comet_ml = import_comet_ml()
+
+    experiment = comet_ml.Experiment(
+        workspace=workspace,
+        project_name=project_name,
+    )
+
+    return experiment
+
+
+def _fetch_text_complexity_metrics(text: str) -> dict:
+    textstat = import_textstat()
+    text_complexity_metrics = {
+        "flesch_reading_ease": textstat.flesch_reading_ease(text),
+        "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
+        "smog_index": textstat.smog_index(text),
+        "coleman_liau_index": textstat.coleman_liau_index(text),
+        "automated_readability_index": textstat.automated_readability_index(text),
+        "dale_chall_readability_score": textstat.dale_chall_readability_score(text),
+        "difficult_words": textstat.difficult_words(text),
+        "linsear_write_formula": textstat.linsear_write_formula(text),
+        "gunning_fog": textstat.gunning_fog(text),
+        "text_standard": textstat.text_standard(text),
+        "fernandez_huerta": textstat.fernandez_huerta(text),
+        "szigriszt_pazos": textstat.szigriszt_pazos(text),
+        "gutierrez_polini": textstat.gutierrez_polini(text),
+        "crawford": textstat.crawford(text),
+        "gulpease_index": textstat.gulpease_index(text),
+        "osman": textstat.osman(text),
+    }
+    return text_complexity_metrics
+
+
+def _summarize_metrics_for_generated_outputs(metrics: Sequence) -> dict:
+    pd = import_pandas()
+    metrics_df = pd.DataFrame(metrics)
+    metrics_summary = metrics_df.describe()
+
+    return metrics_summary.to_dict()
+
+
+class CometCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """Callback Handler that logs to Comet.
+
+    Parameters:
+        job_type (str): The type of comet_ml task such as "inference",
+            "testing" or "qc"
+        project_name (str): The comet_ml project name
+        tags (list): Tags to add to the task
+        task_name (str): Name of the comet_ml task
+        visualize (bool): Whether to visualize the run.
+        complexity_metrics (bool): Whether to log complexity metrics
+        stream_logs (bool): Whether to stream callback actions to Comet
+
+    This handler will utilize the associated callback method and formats
+    the input of each callback function with metadata regarding the state of LLM run,
+    and adds the response to the list of records for both the {method}_records and
+    action. It then logs the response to Comet.
+    """
+
+    def __init__(
+        self,
+        task_type: Optional[str] = "inference",
+        workspace: Optional[str] = None,
+        project_name: Optional[str] = None,
+        tags: Optional[Sequence] = None,
+        name: Optional[str] = None,
+        visualizations: Optional[List[str]] = None,
+        complexity_metrics: bool = False,
+        custom_metrics: Optional[Callable] = None,
+        stream_logs: bool = True,
+    ) -> None:
+        """Initialize callback handler."""
+
+        self.comet_ml = import_comet_ml()
+        super().__init__()
+
+        self.task_type = task_type
+        self.workspace = workspace
+        self.project_name = project_name
+        self.tags = tags
+        self.visualizations = visualizations
+        self.complexity_metrics = complexity_metrics
+        self.custom_metrics = custom_metrics
+        self.stream_logs = stream_logs
+        self.temp_dir = tempfile.TemporaryDirectory()
+
+        self.experiment = _get_experiment(workspace, project_name)
+        self.experiment.log_other("Created from", "langchain")
+        if tags:
+            self.experiment.add_tags(tags)
+        self.name = name
+        if self.name:
+            self.experiment.set_name(self.name)
+
+        warning = (
+            "The comet_ml callback is currently in beta and is subject to change "
+            "based on updates to `langchain`. Please report any issues to "
+            "https://github.com/comet-ml/issue-tracking/issues with the tag "
+            "`langchain`."
+        )
+        self.comet_ml.LOGGER.warning(warning)
+
+        self.callback_columns: list = []
+        self.action_records: list = []
+        self.complexity_metrics = complexity_metrics
+        if self.visualizations:
+            spacy = import_spacy()
+            self.nlp = spacy.load("en_core_web_sm")
+        else:
+            self.nlp = None
+
+    def _init_resp(self) -> Dict:
+        return {k: None for k in self.callback_columns}
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+        self.step += 1
+        self.llm_starts += 1
+        self.starts += 1
+
+        metadata = self._init_resp()
+        metadata.update({"action": "on_llm_start"})
+        metadata.update(flatten_dict(serialized))
+        metadata.update(self.get_custom_callback_meta())
+
+        for prompt in prompts:
+            prompt_resp = deepcopy(metadata)
+            prompt_resp["prompts"] = prompt
+            self.on_llm_start_records.append(prompt_resp)
+            self.action_records.append(prompt_resp)
+
+            if self.stream_logs:
+                self._log_stream(prompt, metadata, self.step)
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+        self.step += 1
+        self.llm_streams += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_new_token", "token": token})
+        resp.update(self.get_custom_callback_meta())
+
+        self.action_records.append(resp)
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.step += 1
+        self.llm_ends += 1
+        self.ends += 1
+
+        metadata = self._init_resp()
+        metadata.update({"action": "on_llm_end"})
+        metadata.update(flatten_dict(response.llm_output or {}))
+        metadata.update(self.get_custom_callback_meta())
+
+        output_complexity_metrics = []
+        output_custom_metrics = []
+
+        for prompt_idx, generations in enumerate(response.generations):
+            for gen_idx, generation in enumerate(generations):
+                text = generation.text
+
+                generation_resp = deepcopy(metadata)
+                generation_resp.update(flatten_dict(generation.dict()))
+
+                complexity_metrics = self._get_complexity_metrics(text)
+                if complexity_metrics:
+                    output_complexity_metrics.append(complexity_metrics)
+                    generation_resp.update(complexity_metrics)
+
+                custom_metrics = self._get_custom_metrics(
+                    generation, prompt_idx, gen_idx
+                )
+                if custom_metrics:
+                    output_custom_metrics.append(custom_metrics)
+                    generation_resp.update(custom_metrics)
+
+                if self.stream_logs:
+                    self._log_stream(text, metadata, self.step)
+
+                self.action_records.append(generation_resp)
+                self.on_llm_end_records.append(generation_resp)
+
+        self._log_text_metrics(output_complexity_metrics, step=self.step)
+        self._log_text_metrics(output_custom_metrics, step=self.step)
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.step += 1
+        self.chain_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        for chain_input_key, chain_input_val in inputs.items():
+            if isinstance(chain_input_val, str):
+                input_resp = deepcopy(resp)
+                if self.stream_logs:
+                    self._log_stream(chain_input_val, resp, self.step)
+                input_resp.update({chain_input_key: chain_input_val})
+                self.action_records.append(input_resp)
+
+            else:
+                self.comet_ml.LOGGER.warning(
+                    f"Unexpected data format provided! "
+                    f"Input Value for {chain_input_key} will not be logged"
+                )
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        self.step += 1
+        self.chain_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_chain_end"})
+        resp.update(self.get_custom_callback_meta())
+
+        for chain_output_key, chain_output_val in outputs.items():
+            if isinstance(chain_output_val, str):
+                output_resp = deepcopy(resp)
+                if self.stream_logs:
+                    self._log_stream(chain_output_val, resp, self.step)
+                output_resp.update({chain_output_key: chain_output_val})
+                self.action_records.append(output_resp)
+            else:
+                self.comet_ml.LOGGER.warning(
+                    f"Unexpected data format provided! "
+                    f"Output Value for {chain_output_key} will not be logged"
+                )
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_tool_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+        if self.stream_logs:
+            self._log_stream(input_str, resp, self.step)
+
+        resp.update({"input_str": input_str})
+        self.action_records.append(resp)
+
+    def on_tool_end(self, output: Any, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        output = str(output)
+        self.step += 1
+        self.tool_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_tool_end"})
+        resp.update(self.get_custom_callback_meta())
+        if self.stream_logs:
+            self._log_stream(output, resp, self.step)
+
+        resp.update({"output": output})
+        self.action_records.append(resp)
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.step += 1
+        self.text_ctr += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_text"})
+        resp.update(self.get_custom_callback_meta())
+        if self.stream_logs:
+            self._log_stream(text, resp, self.step)
+
+        resp.update({"text": text})
+        self.action_records.append(resp)
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.step += 1
+        self.agent_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        output = finish.return_values["output"]
+        log = finish.log
+
+        resp.update({"action": "on_agent_finish", "log": log})
+        resp.update(self.get_custom_callback_meta())
+        if self.stream_logs:
+            self._log_stream(output, resp, self.step)
+
+        resp.update({"output": output})
+        self.action_records.append(resp)
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        tool = action.tool
+        tool_input = str(action.tool_input)
+        log = action.log
+
+        resp = self._init_resp()
+        resp.update({"action": "on_agent_action", "log": log, "tool": tool})
+        resp.update(self.get_custom_callback_meta())
+        if self.stream_logs:
+            self._log_stream(tool_input, resp, self.step)
+
+        resp.update({"tool_input": tool_input})
+        self.action_records.append(resp)
+
+    def _get_complexity_metrics(self, text: str) -> dict:
+        """Compute text complexity metrics using textstat.
+
+        Parameters:
+            text (str): The text to analyze.
+
+        Returns:
+            `dict` containing the complexity metrics.
+        """
+        resp = {}
+        if self.complexity_metrics:
+            text_complexity_metrics = _fetch_text_complexity_metrics(text)
+            resp.update(text_complexity_metrics)
+
+        return resp
+
+    def _get_custom_metrics(
+        self, generation: Generation, prompt_idx: int, gen_idx: int
+    ) -> dict:
+        """Compute Custom Metrics for an LLM Generated Output
+
+        Args:
+            generation (LLMResult): Output generation from an LLM
+            prompt_idx (int): List index of the input prompt
+            gen_idx (int): List index of the generated output
+
+        Returns:
+            dict: `dict` containing the custom metrics.
+        """
+
+        resp = {}
+        if self.custom_metrics:
+            custom_metrics = self.custom_metrics(generation, prompt_idx, gen_idx)
+            resp.update(custom_metrics)
+
+        return resp
+
+    def flush_tracker(
+        self,
+        langchain_asset: Any = None,
+        task_type: Optional[str] = "inference",
+        workspace: Optional[str] = None,
+        project_name: Optional[str] = "comet-langchain-demo",
+        tags: Optional[Sequence] = None,
+        name: Optional[str] = None,
+        visualizations: Optional[List[str]] = None,
+        complexity_metrics: bool = False,
+        custom_metrics: Optional[Callable] = None,
+        finish: bool = False,
+        reset: bool = False,
+    ) -> None:
+        """Flush the tracker and setup the session.
+
+        Everything after this will be a new table.
+
+        Args:
+            name: Name of the performed session so far so it is identifiable
+            langchain_asset: The langchain asset to save.
+            finish: Whether to finish the run.
+
+            Returns:
+                None
+        """
+        self._log_session(langchain_asset)
+
+        if langchain_asset:
+            try:
+                self._log_model(langchain_asset)
+            except Exception:
+                self.comet_ml.LOGGER.error(
+                    "Failed to export agent or LLM to Comet",
+                    exc_info=True,
+                    extra={"show_traceback": True},
+                )
+
+        if finish:
+            self.experiment.end()
+
+        if reset:
+            self._reset(
+                task_type,
+                workspace,
+                project_name,
+                tags,
+                name,
+                visualizations,
+                complexity_metrics,
+                custom_metrics,
+            )
+
+    def _log_stream(self, prompt: str, metadata: dict, step: int) -> None:
+        self.experiment.log_text(prompt, metadata=metadata, step=step)
+
+    def _log_model(self, langchain_asset: Any) -> None:
+        model_parameters = self._get_llm_parameters(langchain_asset)
+        self.experiment.log_parameters(model_parameters, prefix="model")
+
+        langchain_asset_path = Path(self.temp_dir.name, "model.json")
+        model_name = self.name if self.name else LANGCHAIN_MODEL_NAME
+
+        try:
+            if hasattr(langchain_asset, "save"):
+                langchain_asset.save(langchain_asset_path)
+                self.experiment.log_model(model_name, str(langchain_asset_path))
+        except (ValueError, AttributeError, NotImplementedError) as e:
+            if hasattr(langchain_asset, "save_agent"):
+                langchain_asset.save_agent(langchain_asset_path)
+                self.experiment.log_model(model_name, str(langchain_asset_path))
+            else:
+                self.comet_ml.LOGGER.error(
+                    f"{e}"
+                    " Could not save Langchain Asset "
+                    f"for {langchain_asset.__class__.__name__}"
+                )
+
+    def _log_session(self, langchain_asset: Optional[Any] = None) -> None:
+        try:
+            llm_session_df = self._create_session_analysis_dataframe(langchain_asset)
+            # Log the cleaned dataframe as a table
+            self.experiment.log_table("langchain-llm-session.csv", llm_session_df)
+        except Exception:
+            self.comet_ml.LOGGER.warning(
+                "Failed to log session data to Comet",
+                exc_info=True,
+                extra={"show_traceback": True},
+            )
+
+        try:
+            metadata = {"langchain_version": str(langchain_community.__version__)}
+            # Log the langchain low-level records as a JSON file directly
+            self.experiment.log_asset_data(
+                self.action_records, "langchain-action_records.json", metadata=metadata
+            )
+        except Exception:
+            self.comet_ml.LOGGER.warning(
+                "Failed to log session data to Comet",
+                exc_info=True,
+                extra={"show_traceback": True},
+            )
+
+        try:
+            self._log_visualizations(llm_session_df)
+        except Exception:
+            self.comet_ml.LOGGER.warning(
+                "Failed to log visualizations to Comet",
+                exc_info=True,
+                extra={"show_traceback": True},
+            )
+
+    def _log_text_metrics(self, metrics: Sequence[dict], step: int) -> None:
+        if not metrics:
+            return
+
+        metrics_summary = _summarize_metrics_for_generated_outputs(metrics)
+        for key, value in metrics_summary.items():
+            self.experiment.log_metrics(value, prefix=key, step=step)
+
+    def _log_visualizations(self, session_df: Any) -> None:
+        if not (self.visualizations and self.nlp):
+            return
+
+        spacy = import_spacy()
+
+        prompts = session_df["prompts"].tolist()
+        outputs = session_df["text"].tolist()
+
+        for idx, (prompt, output) in enumerate(zip(prompts, outputs)):
+            doc = self.nlp(output)
+            sentence_spans = list(doc.sents)
+
+            for visualization in self.visualizations:
+                try:
+                    html = spacy.displacy.render(
+                        sentence_spans,
+                        style=visualization,
+                        options={"compact": True},
+                        jupyter=False,
+                        page=True,
+                    )
+                    self.experiment.log_asset_data(
+                        html,
+                        name=f"langchain-viz-{visualization}-{idx}.html",
+                        metadata={"prompt": prompt},
+                        step=idx,
+                    )
+                except Exception as e:
+                    self.comet_ml.LOGGER.warning(
+                        e, exc_info=True, extra={"show_traceback": True}
+                    )
+
+        return
+
+    def _reset(
+        self,
+        task_type: Optional[str] = None,
+        workspace: Optional[str] = None,
+        project_name: Optional[str] = None,
+        tags: Optional[Sequence] = None,
+        name: Optional[str] = None,
+        visualizations: Optional[List[str]] = None,
+        complexity_metrics: bool = False,
+        custom_metrics: Optional[Callable] = None,
+    ) -> None:
+        _task_type = task_type if task_type else self.task_type
+        _workspace = workspace if workspace else self.workspace
+        _project_name = project_name if project_name else self.project_name
+        _tags = tags if tags else self.tags
+        _name = name if name else self.name
+        _visualizations = visualizations if visualizations else self.visualizations
+        _complexity_metrics = (
+            complexity_metrics if complexity_metrics else self.complexity_metrics
+        )
+        _custom_metrics = custom_metrics if custom_metrics else self.custom_metrics
+
+        self.__init__(  # type: ignore[misc]
+            task_type=_task_type,
+            workspace=_workspace,
+            project_name=_project_name,
+            tags=_tags,
+            name=_name,
+            visualizations=_visualizations,
+            complexity_metrics=_complexity_metrics,
+            custom_metrics=_custom_metrics,
+        )
+
+        self.reset_callback_meta()
+        self.temp_dir = tempfile.TemporaryDirectory()
+
+    def _create_session_analysis_dataframe(self, langchain_asset: Any = None) -> dict:
+        pd = import_pandas()
+
+        llm_parameters = self._get_llm_parameters(langchain_asset)
+        num_generations_per_prompt = llm_parameters.get("n", 1)
+
+        llm_start_records_df = pd.DataFrame(self.on_llm_start_records)
+        # Repeat each input row based on the number of outputs generated per prompt
+        llm_start_records_df = llm_start_records_df.loc[
+            llm_start_records_df.index.repeat(num_generations_per_prompt)
+        ].reset_index(drop=True)
+        llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
+
+        llm_session_df = pd.merge(
+            llm_start_records_df,
+            llm_end_records_df,
+            left_index=True,
+            right_index=True,
+            suffixes=["_llm_start", "_llm_end"],
+        )
+
+        return llm_session_df
+
+    def _get_llm_parameters(self, langchain_asset: Any = None) -> dict:
+        if not langchain_asset:
+            return {}
+        try:
+            if hasattr(langchain_asset, "agent"):
+                llm_parameters = langchain_asset.agent.llm_chain.llm.dict()
+            elif hasattr(langchain_asset, "llm_chain"):
+                llm_parameters = langchain_asset.llm_chain.llm.dict()
+            elif hasattr(langchain_asset, "llm"):
+                llm_parameters = langchain_asset.llm.dict()
+            else:
+                llm_parameters = langchain_asset.dict()
+        except Exception:
+            return {}
+
+        return llm_parameters

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/confident_callback.py

@@ -0,0 +1,183 @@
+# flake8: noqa
+import os
+import warnings
+from typing import Any, Dict, List, Optional, Union
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.outputs import LLMResult
+
+
+class DeepEvalCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs into deepeval.
+
+    Args:
+        implementation_name: name of the `implementation` in deepeval
+        metrics: A list of metrics
+
+    Raises:
+        ImportError: if the `deepeval` package is not installed.
+
+    Examples:
+        >>> from langchain_community.llms import OpenAI
+        >>> from langchain_community.callbacks import DeepEvalCallbackHandler
+        >>> from deepeval.metrics import AnswerRelevancy
+        >>> metric = AnswerRelevancy(minimum_score=0.3)
+        >>> deepeval_callback = DeepEvalCallbackHandler(
+        ...     implementation_name="exampleImplementation",
+        ...     metrics=[metric],
+        ... )
+        >>> llm = OpenAI(
+        ...     temperature=0,
+        ...     callbacks=[deepeval_callback],
+        ...     verbose=True,
+        ...     openai_api_key="API_KEY_HERE",
+        ... )
+        >>> llm.generate([
+        ...     "What is the best evaluation tool out there? (no bias at all)",
+        ... ])
+        "Deepeval, no doubt about it."
+    """
+
+    REPO_URL: str = "https://github.com/confident-ai/deepeval"
+    ISSUES_URL: str = f"{REPO_URL}/issues"
+    BLOG_URL: str = "https://docs.confident-ai.com"  # noqa: E501
+
+    def __init__(
+        self,
+        metrics: List[Any],
+        implementation_name: Optional[str] = None,
+    ) -> None:
+        """Initializes the `deepevalCallbackHandler`.
+
+        Args:
+            implementation_name: Name of the implementation you want.
+            metrics: What metrics do you want to track?
+
+        Raises:
+            ImportError: if the `deepeval` package is not installed.
+            ConnectionError: if the connection to deepeval fails.
+        """
+
+        super().__init__()
+
+        # Import deepeval (not via `import_deepeval` to keep hints in IDEs)
+        try:
+            import deepeval  # ignore: F401,I001
+        except ImportError:
+            raise ImportError(
+                """To use the deepeval callback manager you need to have the 
+                `deepeval` Python package installed. Please install it with 
+                `pip install deepeval`"""
+            )
+
+        if os.path.exists(".deepeval"):
+            warnings.warn(
+                """You are currently not logging anything to the dashboard, we 
+                recommend using `deepeval login`."""
+            )
+
+        # Set the deepeval variables
+        self.implementation_name = implementation_name
+        self.metrics = metrics
+
+        warnings.warn(
+            (
+                "The `DeepEvalCallbackHandler` is currently in beta and is subject to"
+                " change based on updates to `langchain`. Please report any issues to"
+                f" {self.ISSUES_URL} as an `integration` issue."
+            ),
+        )
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Store the prompts"""
+        self.prompts = prompts
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Do nothing when a new token is generated."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Log records to deepeval when an LLM ends."""
+        from deepeval.metrics.answer_relevancy import AnswerRelevancy
+        from deepeval.metrics.bias_classifier import UnBiasedMetric
+        from deepeval.metrics.metric import Metric
+        from deepeval.metrics.toxic_classifier import NonToxicMetric
+
+        for metric in self.metrics:
+            for i, generation in enumerate(response.generations):
+                # Here, we only measure the first generation's output
+                output = generation[0].text
+                query = self.prompts[i]
+                if isinstance(metric, AnswerRelevancy):
+                    result = metric.measure(
+                        output=output,
+                        query=query,
+                    )
+                    print(f"Answer Relevancy: {result}")  # noqa: T201
+                elif isinstance(metric, UnBiasedMetric):
+                    score = metric.measure(output)
+                    print(f"Bias Score: {score}")  # noqa: T201
+                elif isinstance(metric, NonToxicMetric):
+                    score = metric.measure(output)
+                    print(f"Toxic Score: {score}")  # noqa: T201
+                else:
+                    raise ValueError(
+                        f"""Metric {metric.__name__} is not supported by deepeval 
+                        callbacks."""
+                    )
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM outputs an error."""
+        pass
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Do nothing when chain starts"""
+        pass
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Do nothing when chain ends."""
+        pass
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM chain outputs an error."""
+        pass
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool starts."""
+        pass
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing when agent takes a specific action."""
+        pass
+
+    def on_tool_end(
+        self,
+        output: Any,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool ends."""
+        pass
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when tool outputs an error."""
+        pass
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """Do nothing"""
+        pass
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Do nothing"""
+        pass

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/context_callback.py

@@ -0,0 +1,192 @@
+"""Callback handler for Context AI"""
+
+import os
+from typing import Any, Dict, List
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import BaseMessage
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+
+def import_context() -> Any:
+    """Import the `getcontext` package."""
+    return (
+        guard_import("getcontext", pip_name="python-context"),
+        guard_import("getcontext.token", pip_name="python-context").Credential,
+        guard_import(
+            "getcontext.generated.models", pip_name="python-context"
+        ).Conversation,
+        guard_import("getcontext.generated.models", pip_name="python-context").Message,
+        guard_import(
+            "getcontext.generated.models", pip_name="python-context"
+        ).MessageRole,
+        guard_import("getcontext.generated.models", pip_name="python-context").Rating,
+    )
+
+
+class ContextCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that records transcripts to the Context service.
+
+     (https://context.ai).
+
+    Keyword Args:
+        token (optional): The token with which to authenticate requests to Context.
+            Visit https://with.context.ai/settings to generate a token.
+            If not provided, the value of the `CONTEXT_TOKEN` environment
+            variable will be used.
+
+    Raises:
+        ImportError: if the `context-python` package is not installed.
+
+    Chat Example:
+        >>> from langchain_community.llms import ChatOpenAI
+        >>> from langchain_community.callbacks import ContextCallbackHandler
+        >>> context_callback = ContextCallbackHandler(
+        ...     token="<CONTEXT_TOKEN_HERE>",
+        ... )
+        >>> chat = ChatOpenAI(
+        ...     temperature=0,
+        ...     headers={"user_id": "123"},
+        ...     callbacks=[context_callback],
+        ...     openai_api_key="API_KEY_HERE",
+        ... )
+        >>> messages = [
+        ...     SystemMessage(content="You translate English to French."),
+        ...     HumanMessage(content="I love programming with LangChain."),
+        ... ]
+        >>> chat.invoke(messages)
+
+    Chain Example:
+        >>> from langchain_classic.chains import LLMChain
+        >>> from langchain_community.chat_models import ChatOpenAI
+        >>> from langchain_community.callbacks import ContextCallbackHandler
+        >>> context_callback = ContextCallbackHandler(
+        ...     token="<CONTEXT_TOKEN_HERE>",
+        ... )
+        >>> human_message_prompt = HumanMessagePromptTemplate(
+        ...     prompt=PromptTemplate(
+        ...         template="What is a good name for a company that makes {product}?",
+        ...         input_variables=["product"],
+        ...    ),
+        ... )
+        >>> chat_prompt_template = ChatPromptTemplate.from_messages(
+        ...   [human_message_prompt]
+        ... )
+        >>> callback = ContextCallbackHandler(token)
+        >>> # Note: the same callback object must be shared between the
+        ...   LLM and the chain.
+        >>> chat = ChatOpenAI(temperature=0.9, callbacks=[callback])
+        >>> chain = LLMChain(
+        ...   llm=chat,
+        ...   prompt=chat_prompt_template,
+        ...   callbacks=[callback]
+        ... )
+        >>> chain.run("colorful socks")
+    """
+
+    def __init__(self, token: str = "", verbose: bool = False, **kwargs: Any) -> None:
+        (
+            self.context,
+            self.credential,
+            self.conversation_model,
+            self.message_model,
+            self.message_role_model,
+            self.rating_model,
+        ) = import_context()
+
+        token = token or os.environ.get("CONTEXT_TOKEN") or ""
+
+        self.client = self.context.ContextAPI(credential=self.credential(token))
+
+        self.chain_run_id = None
+
+        self.llm_model = None
+
+        self.messages: List[Any] = []
+        self.metadata: Dict[str, str] = {}
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        *,
+        run_id: UUID,
+        **kwargs: Any,
+    ) -> Any:
+        """Run when the chat model is started."""
+        llm_model = kwargs.get("invocation_params", {}).get("model", None)
+        if llm_model is not None:
+            self.metadata["model"] = llm_model
+
+        if len(messages) == 0:
+            return
+
+        for message in messages[0]:
+            role = self.message_role_model.SYSTEM
+            if message.type == "human":
+                role = self.message_role_model.USER
+            elif message.type == "system":
+                role = self.message_role_model.SYSTEM
+            elif message.type == "ai":
+                role = self.message_role_model.ASSISTANT
+
+            self.messages.append(
+                self.message_model(
+                    message=message.content,
+                    role=role,
+                )
+            )
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends."""
+        if len(response.generations) == 0 or len(response.generations[0]) == 0:
+            return
+
+        if not self.chain_run_id:
+            generation = response.generations[0][0]
+            self.messages.append(
+                self.message_model(
+                    message=generation.text,
+                    role=self.message_role_model.ASSISTANT,
+                )
+            )
+
+            self._log_conversation()
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts."""
+        self.chain_run_id = kwargs.get("run_id", None)
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends."""
+        self.messages.append(
+            self.message_model(
+                message=outputs["text"],
+                role=self.message_role_model.ASSISTANT,
+            )
+        )
+
+        self._log_conversation()
+
+        self.chain_run_id = None
+
+    def _log_conversation(self) -> None:
+        """Log the conversation to the context API."""
+        if len(self.messages) == 0:
+            return
+
+        self.client.log.conversation_upsert(
+            body={
+                "conversation": self.conversation_model(
+                    messages=self.messages,
+                    metadata=self.metadata,
+                )
+            }
+        )
+
+        self.messages = []
+        self.metadata = {}

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/fiddler_callback.py

@@ -0,0 +1,335 @@
+import time
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+from langchain_community.callbacks.utils import import_pandas
+
+# Define constants
+
+# LLMResult keys
+TOKEN_USAGE = "token_usage"
+TOTAL_TOKENS = "total_tokens"
+PROMPT_TOKENS = "prompt_tokens"
+COMPLETION_TOKENS = "completion_tokens"
+RUN_ID = "run_id"
+MODEL_NAME = "model_name"
+GOOD = "good"
+BAD = "bad"
+NEUTRAL = "neutral"
+SUCCESS = "success"
+FAILURE = "failure"
+
+# Default values
+DEFAULT_MAX_TOKEN = 65536
+DEFAULT_MAX_DURATION = 120000
+
+# Fiddler specific constants
+PROMPT = "prompt"
+RESPONSE = "response"
+CONTEXT = "context"
+DURATION = "duration"
+FEEDBACK = "feedback"
+LLM_STATUS = "llm_status"
+
+FEEDBACK_POSSIBLE_VALUES = [GOOD, BAD, NEUTRAL]
+
+# Define a dataset dictionary
+_dataset_dict = {
+    PROMPT: ["fiddler"] * 10,
+    RESPONSE: ["fiddler"] * 10,
+    CONTEXT: ["fiddler"] * 10,
+    FEEDBACK: ["good"] * 10,
+    LLM_STATUS: ["success"] * 10,
+    MODEL_NAME: ["fiddler"] * 10,
+    RUN_ID: ["123e4567-e89b-12d3-a456-426614174000"] * 10,
+    TOTAL_TOKENS: [0, DEFAULT_MAX_TOKEN] * 5,
+    PROMPT_TOKENS: [0, DEFAULT_MAX_TOKEN] * 5,
+    COMPLETION_TOKENS: [0, DEFAULT_MAX_TOKEN] * 5,
+    DURATION: [1, DEFAULT_MAX_DURATION] * 5,
+}
+
+
+def import_fiddler() -> Any:
+    """Import the fiddler python package and raise an error if it is not installed."""
+    return guard_import("fiddler", pip_name="fiddler-client")
+
+
+# First, define custom callback handler implementations
+class FiddlerCallbackHandler(BaseCallbackHandler):
+    def __init__(
+        self,
+        url: str,
+        org: str,
+        project: str,
+        model: str,
+        api_key: str,
+    ) -> None:
+        """
+        Initialize Fiddler callback handler.
+
+        Args:
+            url: Fiddler URL (e.g. https://demo.fiddler.ai).
+                Make sure to include the protocol (http/https).
+            org: Fiddler organization id
+            project: Fiddler project name to publish events to
+            model: Fiddler model name to publish events to
+            api_key: Fiddler authentication token
+        """
+        super().__init__()
+        # Initialize Fiddler client and other necessary properties
+        self.fdl = import_fiddler()
+        self.pd = import_pandas()
+
+        self.url = url
+        self.org = org
+        self.project = project
+        self.model = model
+        self.api_key = api_key
+        self._df = self.pd.DataFrame(_dataset_dict)
+
+        self.run_id_prompts: Dict[UUID, List[str]] = {}
+        self.run_id_response: Dict[UUID, List[str]] = {}
+        self.run_id_starttime: Dict[UUID, int] = {}
+
+        # Initialize Fiddler client here
+        self.fiddler_client = self.fdl.FiddlerApi(url, org_id=org, auth_token=api_key)
+
+        if self.project not in self.fiddler_client.get_project_names():
+            print(  # noqa: T201
+                f"adding project {self.project}.This only has to be done once."
+            )
+            try:
+                self.fiddler_client.add_project(self.project)
+            except Exception as e:
+                print(  # noqa: T201
+                    f"Error adding project {self.project}:"
+                    "{e}. Fiddler integration will not work."
+                )
+                raise e
+
+        dataset_info = self.fdl.DatasetInfo.from_dataframe(
+            self._df, max_inferred_cardinality=0
+        )
+
+        # Set feedback column to categorical
+        for i in range(len(dataset_info.columns)):
+            if dataset_info.columns[i].name == FEEDBACK:
+                dataset_info.columns[i].data_type = self.fdl.DataType.CATEGORY
+                dataset_info.columns[i].possible_values = FEEDBACK_POSSIBLE_VALUES
+
+            elif dataset_info.columns[i].name == LLM_STATUS:
+                dataset_info.columns[i].data_type = self.fdl.DataType.CATEGORY
+                dataset_info.columns[i].possible_values = [SUCCESS, FAILURE]
+
+        if self.model not in self.fiddler_client.get_model_names(self.project):
+            if self.model not in self.fiddler_client.get_dataset_names(self.project):
+                print(  # noqa: T201
+                    f"adding dataset {self.model} to project {self.project}."
+                    "This only has to be done once."
+                )
+                try:
+                    self.fiddler_client.upload_dataset(
+                        project_id=self.project,
+                        dataset_id=self.model,
+                        dataset={"train": self._df},
+                        info=dataset_info,
+                    )
+                except Exception as e:
+                    print(  # noqa: T201
+                        f"Error adding dataset {self.model}: {e}."
+                        "Fiddler integration will not work."
+                    )
+                    raise e
+
+            model_info = self.fdl.ModelInfo.from_dataset_info(
+                dataset_info=dataset_info,
+                dataset_id="train",
+                model_task=self.fdl.ModelTask.LLM,
+                features=[PROMPT, CONTEXT, RESPONSE],
+                target=FEEDBACK,
+                metadata_cols=[
+                    RUN_ID,
+                    TOTAL_TOKENS,
+                    PROMPT_TOKENS,
+                    COMPLETION_TOKENS,
+                    MODEL_NAME,
+                    DURATION,
+                ],
+                custom_features=self.custom_features,
+            )
+            print(  # noqa: T201
+                f"adding model {self.model} to project {self.project}."
+                "This only has to be done once."
+            )
+            try:
+                self.fiddler_client.add_model(
+                    project_id=self.project,
+                    dataset_id=self.model,
+                    model_id=self.model,
+                    model_info=model_info,
+                )
+            except Exception as e:
+                print(  # noqa: T201
+                    f"Error adding model {self.model}: {e}."
+                    "Fiddler integration will not work."
+                )
+                raise e
+
+    @property
+    def custom_features(self) -> list:
+        """
+        Define custom features for the model to automatically enrich the data with.
+        Here, we enable the following enrichments:
+        - Automatic Embedding generation for prompt and response
+        - Text Statistics such as:
+            - Automated Readability Index
+            - Coleman Liau Index
+            - Dale Chall Readability Score
+            - Difficult Words
+            - Flesch Reading Ease
+            - Flesch Kincaid Grade
+            - Gunning Fog
+            - Linsear Write Formula
+        - PII - Personal Identifiable Information
+        - Sentiment Analysis
+
+        """
+
+        return [
+            self.fdl.Enrichment(
+                name="Prompt Embedding",
+                enrichment="embedding",
+                columns=[PROMPT],
+            ),
+            self.fdl.TextEmbedding(
+                name="Prompt CF",
+                source_column=PROMPT,
+                column="Prompt Embedding",
+            ),
+            self.fdl.Enrichment(
+                name="Response Embedding",
+                enrichment="embedding",
+                columns=[RESPONSE],
+            ),
+            self.fdl.TextEmbedding(
+                name="Response CF",
+                source_column=RESPONSE,
+                column="Response Embedding",
+            ),
+            self.fdl.Enrichment(
+                name="Text Statistics",
+                enrichment="textstat",
+                columns=[PROMPT, RESPONSE],
+                config={
+                    "statistics": [
+                        "automated_readability_index",
+                        "coleman_liau_index",
+                        "dale_chall_readability_score",
+                        "difficult_words",
+                        "flesch_reading_ease",
+                        "flesch_kincaid_grade",
+                        "gunning_fog",
+                        "linsear_write_formula",
+                    ]
+                },
+            ),
+            self.fdl.Enrichment(
+                name="PII",
+                enrichment="pii",
+                columns=[PROMPT, RESPONSE],
+            ),
+            self.fdl.Enrichment(
+                name="Sentiment",
+                enrichment="sentiment",
+                columns=[PROMPT, RESPONSE],
+            ),
+        ]
+
+    def _publish_events(
+        self,
+        run_id: UUID,
+        prompt_responses: List[str],
+        duration: int,
+        llm_status: str,
+        model_name: Optional[str] = "",
+        token_usage_dict: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        """
+        Publish events to fiddler
+        """
+
+        prompt_count = len(self.run_id_prompts[run_id])
+        df = self.pd.DataFrame(
+            {
+                PROMPT: self.run_id_prompts[run_id],
+                RESPONSE: prompt_responses,
+                RUN_ID: [str(run_id)] * prompt_count,
+                DURATION: [duration] * prompt_count,
+                LLM_STATUS: [llm_status] * prompt_count,
+                MODEL_NAME: [model_name] * prompt_count,
+            }
+        )
+
+        if token_usage_dict:
+            for key, value in token_usage_dict.items():
+                df[key] = [value] * prompt_count if isinstance(value, int) else value
+
+        try:
+            if df.shape[0] > 1:
+                self.fiddler_client.publish_events_batch(self.project, self.model, df)
+            else:
+                df_dict = df.to_dict(orient="records")
+                self.fiddler_client.publish_event(
+                    self.project, self.model, event=df_dict[0]
+                )
+        except Exception as e:
+            print(  # noqa: T201
+                f"Error publishing events to fiddler: {e}. continuing..."
+            )
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> Any:
+        run_id = kwargs[RUN_ID]
+        self.run_id_prompts[run_id] = prompts
+        self.run_id_starttime[run_id] = int(time.time() * 1000)
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        flattened_llmresult = response.flatten()
+        run_id = kwargs[RUN_ID]
+        run_duration = int(time.time() * 1000) - self.run_id_starttime[run_id]
+        model_name = ""
+        token_usage_dict = {}
+
+        if isinstance(response.llm_output, dict):
+            token_usage_dict = {
+                k: v
+                for k, v in response.llm_output.items()
+                if k in [TOTAL_TOKENS, PROMPT_TOKENS, COMPLETION_TOKENS]
+            }
+            model_name = response.llm_output.get(MODEL_NAME, "")
+
+        prompt_responses = [
+            llmresult.generations[0][0].text for llmresult in flattened_llmresult
+        ]
+
+        self._publish_events(
+            run_id,
+            prompt_responses,
+            run_duration,
+            SUCCESS,
+            model_name,
+            token_usage_dict,
+        )
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        run_id = kwargs[RUN_ID]
+        duration = int(time.time() * 1000) - self.run_id_starttime[run_id]
+
+        self._publish_events(
+            run_id, [""] * len(self.run_id_prompts[run_id]), duration, FAILURE
+        )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/flyte_callback.py

@@ -0,0 +1,364 @@
+"""FlyteKit callback handler."""
+
+from __future__ import annotations
+
+import logging
+from copy import deepcopy
+from typing import TYPE_CHECKING, Any, Dict, List, Tuple
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+from langchain_community.callbacks.utils import (
+    BaseMetadataCallbackHandler,
+    flatten_dict,
+    import_pandas,
+    import_spacy,
+    import_textstat,
+)
+
+if TYPE_CHECKING:
+    import flytekit
+    from flytekitplugins.deck import renderer
+
+logger = logging.getLogger(__name__)
+
+
+def import_flytekit() -> Tuple[flytekit, renderer]:
+    """Import flytekit and flytekitplugins-deck-standard."""
+    return (
+        guard_import("flytekit"),
+        guard_import(
+            "flytekitplugins.deck", pip_name="flytekitplugins-deck-standard"
+        ).renderer,
+    )
+
+
+def analyze_text(
+    text: str,
+    nlp: Any = None,
+    textstat: Any = None,
+) -> dict:
+    """Analyze text using textstat and spacy.
+
+    Parameters:
+        text (str): The text to analyze.
+        nlp (spacy.lang): The spacy language model to use for visualization.
+
+    Returns:
+        `dict` containing the complexity metrics and visualization
+            files serialized to HTML string.
+    """
+    resp: Dict[str, Any] = {}
+    if textstat is not None:
+        text_complexity_metrics = {
+            "flesch_reading_ease": textstat.flesch_reading_ease(text),
+            "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
+            "smog_index": textstat.smog_index(text),
+            "coleman_liau_index": textstat.coleman_liau_index(text),
+            "automated_readability_index": textstat.automated_readability_index(text),
+            "dale_chall_readability_score": textstat.dale_chall_readability_score(text),
+            "difficult_words": textstat.difficult_words(text),
+            "linsear_write_formula": textstat.linsear_write_formula(text),
+            "gunning_fog": textstat.gunning_fog(text),
+            "fernandez_huerta": textstat.fernandez_huerta(text),
+            "szigriszt_pazos": textstat.szigriszt_pazos(text),
+            "gutierrez_polini": textstat.gutierrez_polini(text),
+            "crawford": textstat.crawford(text),
+            "gulpease_index": textstat.gulpease_index(text),
+            "osman": textstat.osman(text),
+        }
+        resp.update({"text_complexity_metrics": text_complexity_metrics})
+        resp.update(text_complexity_metrics)
+
+    if nlp is not None:
+        spacy = import_spacy()
+        doc = nlp(text)
+        dep_out = spacy.displacy.render(doc, style="dep", jupyter=False, page=True)
+        ent_out = spacy.displacy.render(doc, style="ent", jupyter=False, page=True)
+        text_visualizations = {
+            "dependency_tree": dep_out,
+            "entities": ent_out,
+        }
+        resp.update(text_visualizations)
+
+    return resp
+
+
+class FlyteCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """Callback handler that is used within a Flyte task."""
+
+    def __init__(self) -> None:
+        """Initialize callback handler."""
+        flytekit, renderer = import_flytekit()
+        self.pandas = import_pandas()
+
+        self.textstat = None
+        try:
+            self.textstat = import_textstat()
+        except ImportError:
+            logger.warning(
+                "Textstat library is not installed. \
+                It may result in the inability to log \
+                certain metrics that can be captured with Textstat."
+            )
+
+        spacy = None
+        try:
+            spacy = import_spacy()
+        except ImportError:
+            logger.warning(
+                "Spacy library is not installed. \
+                It may result in the inability to log \
+                certain metrics that can be captured with Spacy."
+            )
+
+        super().__init__()
+
+        self.nlp = None
+        if spacy:
+            try:
+                self.nlp = spacy.load("en_core_web_sm")
+            except OSError:
+                logger.warning(
+                    "FlyteCallbackHandler uses spacy's en_core_web_sm model"
+                    " for certain metrics. To download,"
+                    " run the following command in your terminal:"
+                    " `python -m spacy download en_core_web_sm`"
+                )
+
+        self.table_renderer = renderer.TableRenderer
+        self.markdown_renderer = renderer.MarkdownRenderer
+
+        self.deck = flytekit.Deck(
+            "LangChain Metrics",
+            self.markdown_renderer().to_html("## LangChain Metrics"),
+        )
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+
+        self.step += 1
+        self.llm_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        prompt_responses = []
+        for prompt in prompts:
+            prompt_responses.append(prompt)
+
+        resp.update({"prompts": prompt_responses})
+
+        self.deck.append(self.markdown_renderer().to_html("### LLM Start"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.step += 1
+        self.llm_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_end"})
+        resp.update(flatten_dict(response.llm_output or {}))
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### LLM End"))
+        self.deck.append(self.table_renderer().to_html(self.pandas.DataFrame([resp])))
+
+        for generations in response.generations:
+            for generation in generations:
+                generation_resp = deepcopy(resp)
+                generation_resp.update(flatten_dict(generation.dict()))
+                if self.nlp or self.textstat:
+                    generation_resp.update(
+                        analyze_text(
+                            generation.text, nlp=self.nlp, textstat=self.textstat
+                        )
+                    )
+
+                    complexity_metrics: Dict[str, float] = generation_resp.pop(
+                        "text_complexity_metrics"
+                    )
+                    self.deck.append(
+                        self.markdown_renderer().to_html("#### Text Complexity Metrics")
+                    )
+                    self.deck.append(
+                        self.table_renderer().to_html(
+                            self.pandas.DataFrame([complexity_metrics])
+                        )
+                        + "\n"
+                    )
+
+                    dependency_tree = generation_resp["dependency_tree"]
+                    self.deck.append(
+                        self.markdown_renderer().to_html("#### Dependency Tree")
+                    )
+                    self.deck.append(dependency_tree)
+
+                    entities = generation_resp["entities"]
+                    self.deck.append(self.markdown_renderer().to_html("#### Entities"))
+                    self.deck.append(entities)
+                else:
+                    self.deck.append(
+                        self.markdown_renderer().to_html("#### Generated Response")
+                    )
+                    self.deck.append(self.markdown_renderer().to_html(generation.text))
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.step += 1
+        self.chain_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        chain_input = ",".join([f"{k}={v}" for k, v in inputs.items()])
+        input_resp = deepcopy(resp)
+        input_resp["inputs"] = chain_input
+
+        self.deck.append(self.markdown_renderer().to_html("### Chain Start"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([input_resp])) + "\n"
+        )
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        self.step += 1
+        self.chain_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        chain_output = ",".join([f"{k}={v}" for k, v in outputs.items()])
+        resp.update({"action": "on_chain_end", "outputs": chain_output})
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Chain End"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_start", "input_str": input_str})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Tool Start"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        self.step += 1
+        self.tool_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_end", "output": output})
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Tool End"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.step += 1
+        self.text_ctr += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_text", "text": text})
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### On Text"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.step += 1
+        self.agent_ends += 1
+        self.ends += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_finish",
+                "output": finish.return_values["output"],
+                "log": finish.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Agent Finish"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_action",
+                "tool": action.tool,
+                "tool_input": action.tool_input,
+                "log": action.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.deck.append(self.markdown_renderer().to_html("### Agent Action"))
+        self.deck.append(
+            self.table_renderer().to_html(self.pandas.DataFrame([resp])) + "\n"
+        )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/human.py

@@ -0,0 +1,88 @@
+from typing import Any, Awaitable, Callable, Dict, Optional
+from uuid import UUID
+
+from langchain_core.callbacks import AsyncCallbackHandler, BaseCallbackHandler
+
+
+def _default_approve(_input: str) -> bool:
+    msg = (
+        "Do you approve of the following input? "
+        "Anything except 'Y'/'Yes' (case-insensitive) will be treated as a no."
+    )
+    msg += "\n\n" + _input + "\n"
+    resp = input(msg)
+    return resp.lower() in ("yes", "y")
+
+
+async def _adefault_approve(_input: str) -> bool:
+    msg = (
+        "Do you approve of the following input? "
+        "Anything except 'Y'/'Yes' (case-insensitive) will be treated as a no."
+    )
+    msg += "\n\n" + _input + "\n"
+    resp = input(msg)
+    return resp.lower() in ("yes", "y")
+
+
+def _default_true(_: Dict[str, Any]) -> bool:
+    return True
+
+
+class HumanRejectedException(Exception):
+    """Exception to raise when a person manually review and rejects a value."""
+
+
+class HumanApprovalCallbackHandler(BaseCallbackHandler):
+    """Callback for manually validating values."""
+
+    raise_error: bool = True
+
+    def __init__(
+        self,
+        approve: Callable[[Any], bool] = _default_approve,
+        should_check: Callable[[Dict[str, Any]], bool] = _default_true,
+    ):
+        self._approve = approve
+        self._should_check = should_check
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self._should_check(serialized) and not self._approve(input_str):
+            raise HumanRejectedException(
+                f"Inputs {input_str} to tool {serialized} were rejected."
+            )
+
+
+class AsyncHumanApprovalCallbackHandler(AsyncCallbackHandler):
+    """Asynchronous callback for manually validating values."""
+
+    raise_error: bool = True
+
+    def __init__(
+        self,
+        approve: Callable[[Any], Awaitable[bool]] = _adefault_approve,
+        should_check: Callable[[Dict[str, Any]], bool] = _default_true,
+    ):
+        self._approve = approve
+        self._should_check = should_check
+
+    async def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self._should_check(serialized) and not await self._approve(input_str):
+            raise HumanRejectedException(
+                f"Inputs {input_str} to tool {serialized} were rejected."
+            )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/infino_callback.py

@@ -0,0 +1,251 @@
+import time
+from typing import Any, Dict, List, Optional, cast
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import BaseMessage
+from langchain_core.outputs import ChatGeneration, LLMResult
+from langchain_core.utils import guard_import
+
+
+def import_infino() -> Any:
+    """Import the infino client."""
+    return guard_import("infinopy").InfinoClient()
+
+
+def import_tiktoken() -> Any:
+    """Import tiktoken for counting tokens for OpenAI models."""
+    return guard_import("tiktoken")
+
+
+def get_num_tokens(string: str, openai_model_name: str) -> int:
+    """Calculate num tokens for OpenAI with tiktoken package.
+
+    Official documentation: https://github.com/openai/openai-cookbook/blob/main
+                            /examples/How_to_count_tokens_with_tiktoken.ipynb
+    """
+    tiktoken = import_tiktoken()
+
+    encoding = tiktoken.encoding_for_model(openai_model_name)
+    num_tokens = len(encoding.encode(string))
+    return num_tokens
+
+
+class InfinoCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs to Infino."""
+
+    def __init__(
+        self,
+        model_id: Optional[str] = None,
+        model_version: Optional[str] = None,
+        verbose: bool = False,
+    ) -> None:
+        # Set Infino client
+        self.client = import_infino()
+        self.model_id = model_id
+        self.model_version = model_version
+        self.verbose = verbose
+        self.is_chat_openai_model = False
+        self.chat_openai_model_name = "gpt-3.5-turbo"
+
+    def _send_to_infino(
+        self,
+        key: str,
+        value: Any,
+        is_ts: bool = True,
+    ) -> None:
+        """Send the key-value to Infino.
+
+        Parameters:
+        key (str): the key to send to Infino.
+        value (Any): the value to send to Infino.
+        is_ts (bool): if True, the value is part of a time series, else it
+                      is sent as a log message.
+        """
+        payload = {
+            "date": int(time.time()),
+            key: value,
+            "labels": {
+                "model_id": self.model_id,
+                "model_version": self.model_version,
+            },
+        }
+        if self.verbose:
+            print(f"Tracking {key} with Infino: {payload}")  # noqa: T201
+
+        # Append to Infino time series only if is_ts is True, otherwise
+        # append to Infino log.
+        if is_ts:
+            self.client.append_ts(payload)
+        else:
+            self.client.append_log(payload)
+
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        **kwargs: Any,
+    ) -> None:
+        """Log the prompts to Infino, and set start time and error flag."""
+        for prompt in prompts:
+            self._send_to_infino("prompt", prompt, is_ts=False)
+
+        # Set the error flag to indicate no error (this will get overridden
+        # in on_llm_error if an error occurs).
+        self.error = 0
+
+        # Set the start time (so that we can calculate the request
+        # duration in on_llm_end).
+        self.start_time = time.time()
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Do nothing when a new token is generated."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Log the latency, error, token usage, and response to Infino."""
+        # Calculate and track the request latency.
+        self.end_time = time.time()
+        duration = self.end_time - self.start_time
+        self._send_to_infino("latency", duration)
+
+        # Track success or error flag.
+        self._send_to_infino("error", self.error)
+
+        # Track prompt response.
+        for generations in response.generations:
+            for generation in generations:
+                self._send_to_infino("prompt_response", generation.text, is_ts=False)
+
+        # Track token usage (for non-chat models).
+        if (response.llm_output is not None) and isinstance(response.llm_output, Dict):
+            token_usage = response.llm_output["token_usage"]
+            if token_usage is not None:
+                prompt_tokens = token_usage["prompt_tokens"]
+                total_tokens = token_usage["total_tokens"]
+                completion_tokens = token_usage["completion_tokens"]
+                self._send_to_infino("prompt_tokens", prompt_tokens)
+                self._send_to_infino("total_tokens", total_tokens)
+                self._send_to_infino("completion_tokens", completion_tokens)
+
+        # Track completion token usage (for openai chat models).
+        if self.is_chat_openai_model:
+            messages = " ".join(
+                cast(str, cast(ChatGeneration, generation).message.content)
+                for generation in generations
+            )
+            completion_tokens = get_num_tokens(
+                messages, openai_model_name=self.chat_openai_model_name
+            )
+            self._send_to_infino("completion_tokens", completion_tokens)
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Set the error flag."""
+        self.error = 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Do nothing when LLM chain starts."""
+        pass
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Do nothing when LLM chain ends."""
+        pass
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Need to log the error."""
+        pass
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool starts."""
+        pass
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing when agent takes a specific action."""
+        pass
+
+    def on_tool_end(
+        self,
+        output: str,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool ends."""
+        pass
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when tool outputs an error."""
+        pass
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Do nothing."""
+        pass
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        **kwargs: Any,
+    ) -> None:
+        """Run when LLM starts running."""
+
+        # Currently, for chat models, we only support input prompts for ChatOpenAI.
+        # Check if this model is a ChatOpenAI model.
+        values = serialized.get("id")
+        if values:
+            for value in values:
+                if value == "ChatOpenAI":
+                    self.is_chat_openai_model = True
+                    break
+
+        # Track prompt tokens for ChatOpenAI model.
+        if self.is_chat_openai_model:
+            invocation_params = kwargs.get("invocation_params")
+            if invocation_params:
+                model_name = invocation_params.get("model_name")
+                if model_name:
+                    self.chat_openai_model_name = model_name
+                    prompt_tokens = 0
+                    for message_list in messages:
+                        message_string = " ".join(
+                            cast(str, msg.content) for msg in message_list
+                        )
+                        num_tokens = get_num_tokens(
+                            message_string,
+                            openai_model_name=self.chat_openai_model_name,
+                        )
+                        prompt_tokens += num_tokens
+
+                    self._send_to_infino("prompt_tokens", prompt_tokens)
+
+        if self.verbose:
+            print(  # noqa: T201
+                f"on_chat_model_start: is_chat_openai_model= \
+                  {self.is_chat_openai_model}, \
+                  chat_openai_model_name={self.chat_openai_model_name}"
+            )
+
+        # Send the prompt to infino
+        prompt = " ".join(
+            cast(str, msg.content) for sublist in messages for msg in sublist
+        )
+        self._send_to_infino("prompt", prompt, is_ts=False)
+
+        # Set the error flag to indicate no error (this will get overridden
+        # in on_llm_error if an error occurs).
+        self.error = 0
+
+        # Set the start time (so that we can calculate the request
+        # duration in on_llm_end).
+        self.start_time = time.time()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/labelstudio_callback.py

@@ -0,0 +1,390 @@
+import os
+import warnings
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional, Tuple, Union
+from uuid import UUID
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import BaseMessage, ChatMessage
+from langchain_core.outputs import Generation, LLMResult
+
+
+class LabelStudioMode(Enum):
+    """Label Studio mode enumerator."""
+
+    PROMPT = "prompt"
+    CHAT = "chat"
+
+
+def get_default_label_configs(
+    mode: Union[str, LabelStudioMode],
+) -> Tuple[str, LabelStudioMode]:
+    """Get default Label Studio configs for the given mode.
+
+    Parameters:
+        mode: Label Studio mode ("prompt" or "chat")
+
+    Returns: Tuple of Label Studio config and mode
+    """
+    _default_label_configs = {
+        LabelStudioMode.PROMPT.value: """
+<View>
+<Style>
+    .prompt-box {
+        background-color: white;
+        border-radius: 10px;
+        box-shadow: 0px 4px 6px rgba(0, 0, 0, 0.1);
+        padding: 20px;
+    }
+</Style>
+<View className="root">
+    <View className="prompt-box">
+        <Text name="prompt" value="$prompt"/>
+    </View>
+    <TextArea name="response" toName="prompt"
+              maxSubmissions="1" editable="true"
+              required="true"/>
+</View>
+<Header value="Rate the response:"/>
+<Rating name="rating" toName="prompt"/>
+</View>""",
+        LabelStudioMode.CHAT.value: """
+<View>
+<View className="root">
+     <Paragraphs name="dialogue"
+               value="$prompt"
+               layout="dialogue"
+               textKey="content"
+               nameKey="role"
+               granularity="sentence"/>
+  <Header value="Final response:"/>
+    <TextArea name="response" toName="dialogue"
+              maxSubmissions="1" editable="true"
+              required="true"/>
+</View>
+<Header value="Rate the response:"/>
+<Rating name="rating" toName="dialogue"/>
+</View>""",
+    }
+
+    if isinstance(mode, str):
+        mode = LabelStudioMode(mode)
+
+    return _default_label_configs[mode.value], mode
+
+
+class LabelStudioCallbackHandler(BaseCallbackHandler):
+    """Label Studio callback handler.
+    Provides the ability to send predictions to Label Studio
+    for human evaluation, feedback and annotation.
+
+    Parameters:
+        api_key: Label Studio API key
+        url: Label Studio URL
+        project_id: Label Studio project ID
+        project_name: Label Studio project name
+        project_config: Label Studio project config (XML)
+        mode: Label Studio mode ("prompt" or "chat")
+
+    Examples:
+        >>> from langchain_community.llms import OpenAI
+        >>> from langchain_community.callbacks import LabelStudioCallbackHandler
+        >>> handler = LabelStudioCallbackHandler(
+        ...             api_key='<your_key_here>',
+        ...             url='http://localhost:8080',
+        ...             project_name='LangChain-%Y-%m-%d',
+        ...             mode='prompt'
+        ... )
+        >>> llm = OpenAI(callbacks=[handler])
+        >>> llm.invoke('Tell me a story about a dog.')
+    """
+
+    DEFAULT_PROJECT_NAME: str = "LangChain-%Y-%m-%d"
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        url: Optional[str] = None,
+        project_id: Optional[int] = None,
+        project_name: str = DEFAULT_PROJECT_NAME,
+        project_config: Optional[str] = None,
+        mode: Union[str, LabelStudioMode] = LabelStudioMode.PROMPT,
+    ):
+        super().__init__()
+
+        # Import LabelStudio SDK
+        try:
+            import label_studio_sdk as ls
+        except ImportError:
+            raise ImportError(
+                f"You're using {self.__class__.__name__} in your code,"
+                f" but you don't have the LabelStudio SDK "
+                f"Python package installed or upgraded to the latest version. "
+                f"Please run `pip install -U label-studio-sdk`"
+                f" before using this callback."
+            )
+
+        # Check if Label Studio API key is provided
+        if not api_key:
+            if os.getenv("LABEL_STUDIO_API_KEY"):
+                api_key = str(os.getenv("LABEL_STUDIO_API_KEY"))
+            else:
+                raise ValueError(
+                    f"You're using {self.__class__.__name__} in your code,"
+                    f" Label Studio API key is not provided. "
+                    f"Please provide Label Studio API key: "
+                    f"go to the Label Studio instance, navigate to "
+                    f"Account & Settings -> Access Token and copy the key. "
+                    f"Use the key as a parameter for the callback: "
+                    f"{self.__class__.__name__}"
+                    f"(label_studio_api_key='<your_key_here>', ...) or "
+                    f"set the environment variable LABEL_STUDIO_API_KEY=<your_key_here>"
+                )
+        self.api_key = api_key
+
+        if not url:
+            if os.getenv("LABEL_STUDIO_URL"):
+                url = os.getenv("LABEL_STUDIO_URL")
+            else:
+                warnings.warn(
+                    f"Label Studio URL is not provided, "
+                    f"using default URL: {ls.LABEL_STUDIO_DEFAULT_URL}"
+                    f"If you want to provide your own URL, use the parameter: "
+                    f"{self.__class__.__name__}"
+                    f"(label_studio_url='<your_url_here>', ...) "
+                    f"or set the environment variable LABEL_STUDIO_URL=<your_url_here>"
+                )
+                url = ls.LABEL_STUDIO_DEFAULT_URL
+        self.url = url
+
+        # Maps run_id to prompts
+        self.payload: Dict[str, Dict] = {}
+
+        self.ls_client = ls.Client(url=self.url, api_key=self.api_key)
+        self.project_name = project_name
+        if project_config:
+            self.project_config = project_config
+            self.mode = None
+        else:
+            self.project_config, self.mode = get_default_label_configs(mode)
+
+        self.project_id = project_id or os.getenv("LABEL_STUDIO_PROJECT_ID")
+        if self.project_id is not None:
+            self.ls_project = self.ls_client.get_project(int(self.project_id))
+        else:
+            project_title = datetime.today().strftime(self.project_name)
+            existing_projects = self.ls_client.get_projects(title=project_title)
+            if existing_projects:
+                self.ls_project = existing_projects[0]
+                self.project_id = self.ls_project.id
+            else:
+                self.ls_project = self.ls_client.create_project(
+                    title=project_title, label_config=self.project_config
+                )
+                self.project_id = self.ls_project.id
+        self.parsed_label_config = self.ls_project.parsed_label_config
+
+        # Find the first TextArea tag
+        # "from_name", "to_name", "value" will be used to create predictions
+        self.from_name, self.to_name, self.value, self.input_type = (
+            None,
+            None,
+            None,
+            None,
+        )
+        for tag_name, tag_info in self.parsed_label_config.items():
+            if tag_info["type"] == "TextArea":
+                self.from_name = tag_name
+                self.to_name = tag_info["to_name"][0]
+                self.value = tag_info["inputs"][0]["value"]
+                self.input_type = tag_info["inputs"][0]["type"]
+                break
+        if not self.from_name:
+            error_message = (
+                f'Label Studio project "{self.project_name}" '
+                f"does not have a TextArea tag. "
+                f"Please add a TextArea tag to the project."
+            )
+            if self.mode == LabelStudioMode.PROMPT:
+                error_message += (
+                    "\nHINT: go to project Settings -> "
+                    "Labeling Interface -> Browse Templates"
+                    ' and select "Generative AI -> '
+                    'Supervised Language Model Fine-tuning" template.'
+                )
+            else:
+                error_message += (
+                    "\nHINT: go to project Settings -> "
+                    "Labeling Interface -> Browse Templates"
+                    " and check available templates under "
+                    '"Generative AI" section.'
+                )
+            raise ValueError(error_message)
+
+    def add_prompts_generations(
+        self, run_id: str, generations: List[List[Generation]]
+    ) -> None:
+        # Create tasks in Label Studio
+        tasks = []
+        prompts = self.payload[run_id]["prompts"]
+        model_version = (
+            self.payload[run_id]["kwargs"]
+            .get("invocation_params", {})
+            .get("model_name")
+        )
+        for prompt, generation in zip(prompts, generations):
+            tasks.append(
+                {
+                    "data": {
+                        self.value: prompt,
+                        "run_id": run_id,
+                    },
+                    "predictions": [
+                        {
+                            "result": [
+                                {
+                                    "from_name": self.from_name,
+                                    "to_name": self.to_name,
+                                    "type": "textarea",
+                                    "value": {"text": [g.text for g in generation]},
+                                }
+                            ],
+                            "model_version": model_version,
+                        }
+                    ],
+                }
+            )
+        self.ls_project.import_tasks(tasks)
+
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        **kwargs: Any,
+    ) -> None:
+        """Save the prompts in memory when an LLM starts."""
+        if self.input_type != "Text":
+            raise ValueError(
+                f'\nLabel Studio project "{self.project_name}" '
+                f"has an input type <{self.input_type}>. "
+                f'To make it work with the mode="chat", '
+                f"the input type should be <Text>.\n"
+                f"Read more here https://labelstud.io/tags/text"
+            )
+        run_id = str(kwargs["run_id"])
+        self.payload[run_id] = {"prompts": prompts, "kwargs": kwargs}
+
+    def _get_message_role(self, message: BaseMessage) -> str:
+        """Get the role of the message."""
+        if isinstance(message, ChatMessage):
+            return message.role
+        else:
+            return message.__class__.__name__
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Save the prompts in memory when an LLM starts."""
+        if self.input_type != "Paragraphs":
+            raise ValueError(
+                f'\nLabel Studio project "{self.project_name}" '
+                f"has an input type <{self.input_type}>. "
+                f'To make it work with the mode="chat", '
+                f"the input type should be <Paragraphs>.\n"
+                f"Read more here https://labelstud.io/tags/paragraphs"
+            )
+
+        prompts = []
+        for message_list in messages:
+            dialog = []
+            for message in message_list:
+                dialog.append(
+                    {
+                        "role": self._get_message_role(message),
+                        "content": message.content,
+                    }
+                )
+            prompts.append(dialog)
+        self.payload[str(run_id)] = {
+            "prompts": prompts,
+            "tags": tags,
+            "metadata": metadata,
+            "run_id": run_id,
+            "parent_run_id": parent_run_id,
+            "kwargs": kwargs,
+        }
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Do nothing when a new token is generated."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Create a new Label Studio task for each prompt and generation."""
+        run_id = str(kwargs["run_id"])
+
+        # Submit results to Label Studio
+        self.add_prompts_generations(run_id, response.generations)
+
+        # Pop current run from `self.runs`
+        self.payload.pop(run_id)
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM outputs an error."""
+        pass
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        pass
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        pass
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when LLM chain outputs an error."""
+        pass
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool starts."""
+        pass
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Do nothing when agent takes a specific action."""
+        pass
+
+    def on_tool_end(
+        self,
+        output: str,
+        observation_prefix: Optional[str] = None,
+        llm_prefix: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when tool ends."""
+        pass
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Do nothing when tool outputs an error."""
+        pass
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """Do nothing"""
+        pass
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Do nothing"""
+        pass

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/llmonitor_callback.py

@@ -0,0 +1,681 @@
+import importlib.metadata
+import logging
+import os
+import traceback
+import warnings
+from contextvars import ContextVar
+from typing import Any, Dict, List, Union, cast
+from uuid import UUID
+
+import requests
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import BaseMessage
+from langchain_core.outputs import LLMResult
+from packaging.version import parse
+
+logger = logging.getLogger(__name__)
+
+DEFAULT_API_URL = "https://app.llmonitor.com"
+
+user_ctx = ContextVar[Union[str, None]]("user_ctx", default=None)
+user_props_ctx = ContextVar[Union[str, None]]("user_props_ctx", default=None)
+
+PARAMS_TO_CAPTURE = [
+    "temperature",
+    "top_p",
+    "top_k",
+    "stop",
+    "presence_penalty",
+    "frequence_penalty",
+    "seed",
+    "function_call",
+    "functions",
+    "tools",
+    "tool_choice",
+    "response_format",
+    "max_tokens",
+    "logit_bias",
+]
+
+
+class UserContextManager:
+    """Context manager for LLMonitor user context."""
+
+    def __init__(self, user_id: str, user_props: Any = None) -> None:
+        user_ctx.set(user_id)
+        user_props_ctx.set(user_props)
+
+    def __enter__(self) -> Any:
+        pass
+
+    def __exit__(self, exc_type: Any, exc_value: Any, exc_tb: Any) -> Any:
+        user_ctx.set(None)
+        user_props_ctx.set(None)
+
+
+def identify(user_id: str, user_props: Any = None) -> UserContextManager:
+    """Builds an LLMonitor UserContextManager
+
+    Parameters:
+        - `user_id`: The user id.
+        - `user_props`: The user properties.
+
+    Returns:
+        A context manager that sets the user context.
+    """
+    return UserContextManager(user_id, user_props)
+
+
+def _serialize(obj: Any) -> Union[Dict[str, Any], List[Any], Any]:
+    if hasattr(obj, "to_json"):
+        return obj.to_json()
+
+    if isinstance(obj, dict):
+        return {key: _serialize(value) for key, value in obj.items()}
+
+    if isinstance(obj, list):
+        return [_serialize(element) for element in obj]
+
+    return obj
+
+
+def _parse_input(raw_input: Any) -> Any:
+    if not raw_input:
+        return None
+
+    # if it's an array of 1, just parse the first element
+    if isinstance(raw_input, list) and len(raw_input) == 1:
+        return _parse_input(raw_input[0])
+
+    if not isinstance(raw_input, dict):
+        return _serialize(raw_input)
+
+    input_value = raw_input.get("input")
+    inputs_value = raw_input.get("inputs")
+    question_value = raw_input.get("question")
+    query_value = raw_input.get("query")
+
+    if input_value:
+        return input_value
+    if inputs_value:
+        return inputs_value
+    if question_value:
+        return question_value
+    if query_value:
+        return query_value
+
+    return _serialize(raw_input)
+
+
+def _parse_output(raw_output: dict) -> Any:
+    if not raw_output:
+        return None
+
+    if not isinstance(raw_output, dict):
+        return _serialize(raw_output)
+
+    text_value = raw_output.get("text")
+    output_value = raw_output.get("output")
+    output_text_value = raw_output.get("output_text")
+    answer_value = raw_output.get("answer")
+    result_value = raw_output.get("result")
+
+    if text_value:
+        return text_value
+    if answer_value:
+        return answer_value
+    if output_value:
+        return output_value
+    if output_text_value:
+        return output_text_value
+    if result_value:
+        return result_value
+
+    return _serialize(raw_output)
+
+
+def _parse_lc_role(
+    role: str,
+) -> str:
+    if role == "human":
+        return "user"
+    else:
+        return role
+
+
+def _get_user_id(metadata: Any) -> Any:
+    if user_ctx.get() is not None:
+        return user_ctx.get()
+
+    metadata = metadata or {}
+    user_id = metadata.get("user_id")
+    if user_id is None:
+        user_id = metadata.get("userId")  # legacy, to delete in the future
+    return user_id
+
+
+def _get_user_props(metadata: Any) -> Any:
+    if user_props_ctx.get() is not None:
+        return user_props_ctx.get()
+
+    metadata = metadata or {}
+    return metadata.get("user_props", None)
+
+
+def _parse_lc_message(message: BaseMessage) -> Dict[str, Any]:
+    keys = ["function_call", "tool_calls", "tool_call_id", "name"]
+    parsed = {"text": message.content, "role": _parse_lc_role(message.type)}
+    parsed.update(
+        {
+            key: cast(Any, message.additional_kwargs.get(key))
+            for key in keys
+            if message.additional_kwargs.get(key) is not None
+        }
+    )
+    return parsed
+
+
+def _parse_lc_messages(messages: Union[List[BaseMessage], Any]) -> List[Dict[str, Any]]:
+    return [_parse_lc_message(message) for message in messages]
+
+
+class LLMonitorCallbackHandler(BaseCallbackHandler):
+    """Callback Handler for LLMonitor`.
+
+    #### Parameters:
+        - `app_id`: The app id of the app you want to report to. Defaults to
+        `None`, which means that `LLMONITOR_APP_ID` will be used.
+        - `api_url`: The url of the LLMonitor API. Defaults to `None`,
+        which means that either `LLMONITOR_API_URL` environment variable
+        or `https://app.llmonitor.com` will be used.
+
+    #### Raises:
+        - `ValueError`: if `app_id` is not provided either as an
+        argument or as an environment variable.
+        - `ConnectionError`: if the connection to the API fails.
+
+
+    #### Example:
+    ```python
+    from langchain_community.llms import OpenAI
+    from langchain_community.callbacks import LLMonitorCallbackHandler
+
+    llmonitor_callback = LLMonitorCallbackHandler()
+    llm = OpenAI(callbacks=[llmonitor_callback],
+                 metadata={"userId": "user-123"})
+    llm.invoke("Hello, how are you?")
+    ```
+    """
+
+    __api_url: str
+    __app_id: str
+    __verbose: bool
+    __llmonitor_version: str
+    __has_valid_config: bool
+
+    def __init__(
+        self,
+        app_id: Union[str, None] = None,
+        api_url: Union[str, None] = None,
+        verbose: bool = False,
+    ) -> None:
+        super().__init__()
+
+        self.__has_valid_config = True
+
+        try:
+            import llmonitor
+
+            self.__llmonitor_version = importlib.metadata.version("llmonitor")
+            self.__track_event = llmonitor.track_event
+
+        except ImportError:
+            logger.warning(
+                """[LLMonitor] To use the LLMonitor callback handler you need to 
+                have the `llmonitor` Python package installed. Please install it 
+                with `pip install llmonitor`"""
+            )
+            self.__has_valid_config = False
+            return
+
+        if parse(self.__llmonitor_version) < parse("0.0.32"):
+            logger.warning(
+                f"""[LLMonitor] The installed `llmonitor` version is 
+                {self.__llmonitor_version} 
+                but `LLMonitorCallbackHandler` requires at least version 0.0.32 
+                upgrade `llmonitor` with `pip install --upgrade llmonitor`"""
+            )
+            self.__has_valid_config = False
+
+        self.__has_valid_config = True
+
+        self.__api_url = api_url or os.getenv("LLMONITOR_API_URL") or DEFAULT_API_URL
+        self.__verbose = verbose or bool(os.getenv("LLMONITOR_VERBOSE"))
+
+        _app_id = app_id or os.getenv("LLMONITOR_APP_ID")
+        if _app_id is None:
+            logger.warning(
+                """[LLMonitor] app_id must be provided either as an argument or 
+                as an environment variable"""
+            )
+            self.__has_valid_config = False
+        else:
+            self.__app_id = _app_id
+
+        if self.__has_valid_config is False:
+            return None
+
+        try:
+            res = requests.get(f"{self.__api_url}/api/app/{self.__app_id}")
+            if not res.ok:
+                raise ConnectionError()
+        except Exception:
+            logger.warning(
+                f"""[LLMonitor] Could not connect to the LLMonitor API at 
+                {self.__api_url}"""
+            )
+
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        tags: Union[List[str], None] = None,
+        metadata: Union[Dict[str, Any], None] = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.__has_valid_config is False:
+            return
+        try:
+            user_id = _get_user_id(metadata)
+            user_props = _get_user_props(metadata)
+
+            params = kwargs.get("invocation_params", {})
+            params.update(
+                serialized.get("kwargs", {})
+            )  # Sometimes, for example with ChatAnthropic, `invocation_params` is empty
+
+            name = (
+                params.get("model")
+                or params.get("model_name")
+                or params.get("model_id")
+            )
+
+            if not name and "anthropic" in params.get("_type"):
+                name = "claude-2"
+
+            extra = {
+                param: params.get(param)
+                for param in PARAMS_TO_CAPTURE
+                if params.get(param) is not None
+            }
+
+            input = _parse_input(prompts)
+
+            self.__track_event(
+                "llm",
+                "start",
+                user_id=user_id,
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                name=name,
+                input=input,
+                tags=tags,
+                extra=extra,
+                metadata=metadata,
+                user_props=user_props,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            warnings.warn(f"[LLMonitor] An error occurred in on_llm_start: {e}")
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        tags: Union[List[str], None] = None,
+        metadata: Union[Dict[str, Any], None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+
+        try:
+            user_id = _get_user_id(metadata)
+            user_props = _get_user_props(metadata)
+
+            params = kwargs.get("invocation_params", {})
+            params.update(
+                serialized.get("kwargs", {})
+            )  # Sometimes, for example with ChatAnthropic, `invocation_params` is empty
+
+            name = (
+                params.get("model")
+                or params.get("model_name")
+                or params.get("model_id")
+            )
+
+            if not name and "anthropic" in params.get("_type"):
+                name = "claude-2"
+
+            extra = {
+                param: params.get(param)
+                for param in PARAMS_TO_CAPTURE
+                if params.get(param) is not None
+            }
+
+            input = _parse_lc_messages(messages[0])
+
+            self.__track_event(
+                "llm",
+                "start",
+                user_id=user_id,
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                name=name,
+                input=input,
+                tags=tags,
+                extra=extra,
+                metadata=metadata,
+                user_props=user_props,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_chat_model_start: {e}")
+
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.__has_valid_config is False:
+            return
+
+        try:
+            token_usage = (response.llm_output or {}).get("token_usage", {})
+
+            parsed_output: Any = [
+                _parse_lc_message(generation.message)
+                if hasattr(generation, "message")
+                else generation.text
+                for generation in response.generations[0]
+            ]
+
+            # if it's an array of 1, just parse the first element
+            if len(parsed_output) == 1:
+                parsed_output = parsed_output[0]
+
+            self.__track_event(
+                "llm",
+                "end",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                output=parsed_output,
+                token_usage={
+                    "prompt": token_usage.get("prompt_tokens"),
+                    "completion": token_usage.get("completion_tokens"),
+                },
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_llm_end: {e}")
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        tags: Union[List[str], None] = None,
+        metadata: Union[Dict[str, Any], None] = None,
+        **kwargs: Any,
+    ) -> None:
+        if self.__has_valid_config is False:
+            return
+        try:
+            user_id = _get_user_id(metadata)
+            user_props = _get_user_props(metadata)
+            name = serialized.get("name")
+
+            self.__track_event(
+                "tool",
+                "start",
+                user_id=user_id,
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                name=name,
+                input=input_str,
+                tags=tags,
+                metadata=metadata,
+                user_props=user_props,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_tool_start: {e}")
+
+    def on_tool_end(
+        self,
+        output: Any,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        tags: Union[List[str], None] = None,
+        **kwargs: Any,
+    ) -> None:
+        output = str(output)
+        if self.__has_valid_config is False:
+            return
+        try:
+            self.__track_event(
+                "tool",
+                "end",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                output=output,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_tool_end: {e}")
+
+    def on_chain_start(
+        self,
+        serialized: Dict[str, Any],
+        inputs: Dict[str, Any],
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        tags: Union[List[str], None] = None,
+        metadata: Union[Dict[str, Any], None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            name = serialized.get("id", [None, None, None, None])[3]
+            type = "chain"
+            metadata = metadata or {}
+
+            agentName = metadata.get("agent_name")
+            if agentName is None:
+                agentName = metadata.get("agentName")
+
+            if name == "AgentExecutor" or name == "PlanAndExecute":
+                type = "agent"
+            if agentName is not None:
+                type = "agent"
+                name = agentName
+            if parent_run_id is not None:
+                type = "chain"
+
+            user_id = _get_user_id(metadata)
+            user_props = _get_user_props(metadata)
+            input = _parse_input(inputs)
+
+            self.__track_event(
+                type,
+                "start",
+                user_id=user_id,
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                name=name,
+                input=input,
+                tags=tags,
+                metadata=metadata,
+                user_props=user_props,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_chain_start: {e}")
+
+    def on_chain_end(
+        self,
+        outputs: Dict[str, Any],
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            output = _parse_output(outputs)
+
+            self.__track_event(
+                "chain",
+                "end",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                output=output,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_chain_end: {e}")
+
+    def on_agent_action(
+        self,
+        action: AgentAction,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            name = action.tool
+            input = _parse_input(action.tool_input)
+
+            self.__track_event(
+                "tool",
+                "start",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                name=name,
+                input=input,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_agent_action: {e}")
+
+    def on_agent_finish(
+        self,
+        finish: AgentFinish,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            output = _parse_output(finish.return_values)
+
+            self.__track_event(
+                "agent",
+                "end",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                output=output,
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_agent_finish: {e}")
+
+    def on_chain_error(
+        self,
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            self.__track_event(
+                "chain",
+                "error",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                error={"message": str(error), "stack": traceback.format_exc()},
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_chain_error: {e}")
+
+    def on_tool_error(
+        self,
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            self.__track_event(
+                "tool",
+                "error",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                error={"message": str(error), "stack": traceback.format_exc()},
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_tool_error: {e}")
+
+    def on_llm_error(
+        self,
+        error: BaseException,
+        *,
+        run_id: UUID,
+        parent_run_id: Union[UUID, None] = None,
+        **kwargs: Any,
+    ) -> Any:
+        if self.__has_valid_config is False:
+            return
+        try:
+            self.__track_event(
+                "llm",
+                "error",
+                run_id=str(run_id),
+                parent_run_id=str(parent_run_id) if parent_run_id else None,
+                error={"message": str(error), "stack": traceback.format_exc()},
+                app_id=self.__app_id,
+            )
+        except Exception as e:
+            logger.error(f"[LLMonitor] An error occurred in on_llm_error: {e}")
+
+
+__all__ = ["LLMonitorCallbackHandler", "identify"]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/manager.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+import logging
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import (
+    Generator,
+    Optional,
+)
+
+from langchain_core.tracers.context import register_configure_hook
+
+from langchain_community.callbacks.bedrock_anthropic_callback import (
+    BedrockAnthropicTokenUsageCallbackHandler,
+)
+from langchain_community.callbacks.openai_info import OpenAICallbackHandler
+from langchain_community.callbacks.tracers.comet import CometTracer
+from langchain_community.callbacks.tracers.wandb import WandbTracer
+
+logger = logging.getLogger(__name__)
+
+openai_callback_var: ContextVar[Optional[OpenAICallbackHandler]] = ContextVar(
+    "openai_callback", default=None
+)
+bedrock_anthropic_callback_var: (ContextVar)[
+    Optional[BedrockAnthropicTokenUsageCallbackHandler]
+] = ContextVar("bedrock_anthropic_callback", default=None)
+wandb_tracing_callback_var: ContextVar[Optional[WandbTracer]] = ContextVar(
+    "tracing_wandb_callback", default=None
+)
+comet_tracing_callback_var: ContextVar[Optional[CometTracer]] = ContextVar(
+    "tracing_comet_callback", default=None
+)
+
+register_configure_hook(openai_callback_var, True)
+register_configure_hook(bedrock_anthropic_callback_var, True)
+register_configure_hook(
+    wandb_tracing_callback_var, True, WandbTracer, "LANGCHAIN_WANDB_TRACING"
+)
+register_configure_hook(
+    comet_tracing_callback_var, True, CometTracer, "LANGCHAIN_COMET_TRACING"
+)
+
+
+@contextmanager
+def get_openai_callback() -> Generator[OpenAICallbackHandler, None, None]:
+    """Get the OpenAI callback handler in a context manager.
+    which conveniently exposes token and cost information.
+
+    Returns:
+        OpenAICallbackHandler: The OpenAI callback handler.
+
+    Example:
+        >>> with get_openai_callback() as cb:
+        ...     # Use the OpenAI callback handler
+    """
+    cb = OpenAICallbackHandler()
+    openai_callback_var.set(cb)
+    yield cb
+    openai_callback_var.set(None)
+
+
+@contextmanager
+def get_bedrock_anthropic_callback() -> Generator[
+    BedrockAnthropicTokenUsageCallbackHandler, None, None
+]:
+    """Get the Bedrock anthropic callback handler in a context manager.
+    which conveniently exposes token and cost information.
+
+    Returns:
+        BedrockAnthropicTokenUsageCallbackHandler:
+            The Bedrock anthropic callback handler.
+
+    Example:
+        >>> with get_bedrock_anthropic_callback() as cb:
+        ...     # Use the Bedrock anthropic callback handler
+    """
+    cb = BedrockAnthropicTokenUsageCallbackHandler()
+    bedrock_anthropic_callback_var.set(cb)
+    yield cb
+    bedrock_anthropic_callback_var.set(None)
+
+
+@contextmanager
+def wandb_tracing_enabled(
+    session_name: str = "default",
+) -> Generator[None, None, None]:
+    """Get the WandbTracer in a context manager.
+
+    Args:
+        session_name (str, optional): The name of the session.
+            Defaults to "default".
+
+    Returns:
+        None
+
+    Example:
+        >>> with wandb_tracing_enabled() as session:
+        ...     # Use the WandbTracer session
+    """
+    cb = WandbTracer()
+    wandb_tracing_callback_var.set(cb)
+    yield None
+    wandb_tracing_callback_var.set(None)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/mlflow_callback.py

@@ -0,0 +1,769 @@
+import logging
+import os
+import random
+import string
+import tempfile
+import traceback
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.documents import Document
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import get_from_dict_or_env, guard_import
+
+from langchain_community.callbacks.utils import (
+    BaseMetadataCallbackHandler,
+    flatten_dict,
+    hash_string,
+    import_pandas,
+    import_spacy,
+    import_textstat,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def import_mlflow() -> Any:
+    """Import the mlflow python package and raise an error if it is not installed."""
+    return guard_import("mlflow")
+
+
+def mlflow_callback_metrics() -> List[str]:
+    """Get the metrics to log to MLFlow."""
+    return [
+        "step",
+        "starts",
+        "ends",
+        "errors",
+        "text_ctr",
+        "chain_starts",
+        "chain_ends",
+        "llm_starts",
+        "llm_ends",
+        "llm_streams",
+        "tool_starts",
+        "tool_ends",
+        "agent_ends",
+        "retriever_starts",
+        "retriever_ends",
+    ]
+
+
+def get_text_complexity_metrics() -> List[str]:
+    """Get the text complexity metrics from textstat."""
+    return [
+        "flesch_reading_ease",
+        "flesch_kincaid_grade",
+        "smog_index",
+        "coleman_liau_index",
+        "automated_readability_index",
+        "dale_chall_readability_score",
+        "difficult_words",
+        "linsear_write_formula",
+        "gunning_fog",
+        # "text_standard"
+        "fernandez_huerta",
+        "szigriszt_pazos",
+        "gutierrez_polini",
+        "crawford",
+        "gulpease_index",
+        "osman",
+    ]
+
+
+def analyze_text(
+    text: str,
+    nlp: Any = None,
+    textstat: Any = None,
+) -> dict:
+    """Analyze text using textstat and spacy.
+
+    Parameters:
+        text (str): The text to analyze.
+        nlp (spacy.lang): The spacy language model to use for visualization.
+        textstat: The textstat library to use for complexity metrics calculation.
+
+    Returns:
+        `dict` containing the complexity metrics and visualization
+            files serialized to  HTML string.
+    """
+    resp: Dict[str, Any] = {}
+    if textstat is not None:
+        text_complexity_metrics = {
+            key: getattr(textstat, key)(text) for key in get_text_complexity_metrics()
+        }
+        resp.update({"text_complexity_metrics": text_complexity_metrics})
+        resp.update(text_complexity_metrics)
+
+    if nlp is not None:
+        spacy = import_spacy()
+        doc = nlp(text)
+
+        dep_out = spacy.displacy.render(doc, style="dep", jupyter=False, page=True)
+
+        ent_out = spacy.displacy.render(doc, style="ent", jupyter=False, page=True)
+
+        text_visualizations = {
+            "dependency_tree": dep_out,
+            "entities": ent_out,
+        }
+
+        resp.update(text_visualizations)
+
+    return resp
+
+
+def construct_html_from_prompt_and_generation(prompt: str, generation: str) -> Any:
+    """Construct an html element from a prompt and a generation.
+
+    Parameters:
+        prompt (str): The prompt.
+        generation (str): The generation.
+
+    Returns:
+        (str): The html string."""
+    formatted_prompt = prompt.replace("\n", "<br>")
+    formatted_generation = generation.replace("\n", "<br>")
+
+    return f"""
+    <p style="color:black;">{formatted_prompt}:</p>
+    <blockquote>
+      <p style="color:green;">
+        {formatted_generation}
+      </p>
+    </blockquote>
+    """
+
+
+class MlflowLogger:
+    """Callback Handler that logs metrics and artifacts to mlflow server.
+
+    Parameters:
+        name (str): Name of the run.
+        experiment (str): Name of the experiment.
+        tags (dict): Tags to be attached for the run.
+        tracking_uri (str): MLflow tracking server uri.
+
+    This handler implements the helper functions to initialize,
+    log metrics and artifacts to the mlflow server.
+    """
+
+    def __init__(self, **kwargs: Any):
+        self.mlflow = import_mlflow()
+        if "DATABRICKS_RUNTIME_VERSION" in os.environ:
+            self.mlflow.set_tracking_uri("databricks")
+            self.mlf_expid = self.mlflow.tracking.fluent._get_experiment_id()
+            self.mlf_exp = self.mlflow.get_experiment(self.mlf_expid)
+        else:
+            tracking_uri = get_from_dict_or_env(
+                kwargs, "tracking_uri", "MLFLOW_TRACKING_URI", ""
+            )
+            self.mlflow.set_tracking_uri(tracking_uri)
+
+            if run_id := kwargs.get("run_id"):
+                self.mlf_expid = self.mlflow.get_run(run_id).info.experiment_id
+            else:
+                # User can set other env variables described here
+                # > https://www.mlflow.org/docs/latest/tracking.html#logging-to-a-tracking-server
+
+                experiment_name = get_from_dict_or_env(
+                    kwargs, "experiment_name", "MLFLOW_EXPERIMENT_NAME"
+                )
+                self.mlf_exp = self.mlflow.get_experiment_by_name(experiment_name)
+                if self.mlf_exp is not None:
+                    self.mlf_expid = self.mlf_exp.experiment_id
+                else:
+                    self.mlf_expid = self.mlflow.create_experiment(experiment_name)
+
+        self.start_run(
+            kwargs["run_name"], kwargs["run_tags"], kwargs.get("run_id", None)
+        )
+        self.dir = kwargs.get("artifacts_dir", "")
+
+    def start_run(
+        self, name: str, tags: Dict[str, str], run_id: Optional[str] = None
+    ) -> None:
+        """
+        If run_id is provided, it will reuse the run with the given run_id.
+        Otherwise, it starts a new run, auto generates the random suffix for name.
+        """
+        if run_id is None:
+            if name.endswith("-%"):
+                rname = "".join(
+                    random.choices(string.ascii_uppercase + string.digits, k=7)
+                )
+                name = name[:-1] + rname
+            run = self.mlflow.MlflowClient().create_run(
+                self.mlf_expid, run_name=name, tags=tags
+            )
+            run_id = run.info.run_id
+        self.run_id = run_id
+
+    def finish_run(self) -> None:
+        """To finish the run."""
+        self.mlflow.end_run()
+
+    def metric(self, key: str, value: float) -> None:
+        """To log metric to mlflow server."""
+        self.mlflow.log_metric(key, value, run_id=self.run_id)
+
+    def metrics(
+        self, data: Union[Dict[str, float], Dict[str, int]], step: Optional[int] = 0
+    ) -> None:
+        """To log all metrics in the input dict."""
+        self.mlflow.log_metrics(data, run_id=self.run_id)
+
+    def jsonf(self, data: Dict[str, Any], filename: str) -> None:
+        """To log the input data as json file artifact."""
+        self.mlflow.log_dict(
+            data, os.path.join(self.dir, f"{filename}.json"), run_id=self.run_id
+        )
+
+    def table(self, name: str, dataframe: Any) -> None:
+        """To log the input pandas dataframe as a html table"""
+        self.html(dataframe.to_html(), f"table_{name}")
+
+    def html(self, html: str, filename: str) -> None:
+        """To log the input html string as html file artifact."""
+        self.mlflow.log_text(
+            html, os.path.join(self.dir, f"{filename}.html"), run_id=self.run_id
+        )
+
+    def text(self, text: str, filename: str) -> None:
+        """To log the input text as text file artifact."""
+        self.mlflow.log_text(
+            text, os.path.join(self.dir, f"{filename}.txt"), run_id=self.run_id
+        )
+
+    def artifact(self, path: str) -> None:
+        """To upload the file from given path as artifact."""
+        self.mlflow.log_artifact(path, run_id=self.run_id)
+
+    def langchain_artifact(self, chain: Any) -> None:
+        self.mlflow.langchain.log_model(chain, "langchain-model", run_id=self.run_id)
+
+
+class MlflowCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """Callback Handler that logs metrics and artifacts to mlflow server.
+
+    Parameters:
+        name (str): Name of the run.
+        experiment (str): Name of the experiment.
+        tags (dict): Tags to be attached for the run.
+        tracking_uri (str): MLflow tracking server uri.
+
+    This handler will utilize the associated callback method called and formats
+    the input of each callback function with metadata regarding the state of LLM run,
+    and adds the response to the list of records for both the {method}_records and
+    action. It then logs the response to mlflow server.
+    """
+
+    def __init__(
+        self,
+        name: Optional[str] = "langchainrun-%",
+        experiment: Optional[str] = "langchain",
+        tags: Optional[Dict] = None,
+        tracking_uri: Optional[str] = None,
+        run_id: Optional[str] = None,
+        artifacts_dir: str = "",
+    ) -> None:
+        """Initialize callback handler."""
+        import_pandas()
+        import_mlflow()
+        super().__init__()
+
+        self.name = name
+        self.experiment = experiment
+        self.tags = tags or {}
+        self.tracking_uri = tracking_uri
+        self.run_id = run_id
+        self.artifacts_dir = artifacts_dir
+
+        self.temp_dir = tempfile.TemporaryDirectory()
+
+        self.mlflg = MlflowLogger(
+            tracking_uri=self.tracking_uri,
+            experiment_name=self.experiment,
+            run_name=self.name,
+            run_tags=self.tags,
+            run_id=self.run_id,
+            artifacts_dir=self.artifacts_dir,
+        )
+
+        self.action_records: list = []
+        self.nlp = None
+        try:
+            spacy = import_spacy()
+        except ImportError as e:
+            logger.warning(e.msg)
+        else:
+            try:
+                self.nlp = spacy.load("en_core_web_sm")
+            except OSError:
+                logger.warning(
+                    "Run `python -m spacy download en_core_web_sm` "
+                    "to download en_core_web_sm model for text visualization."
+                )
+
+        try:
+            self.textstat = import_textstat()
+        except ImportError as e:
+            logger.warning(e.msg)
+            self.textstat = None
+
+        self.metrics = {key: 0 for key in mlflow_callback_metrics()}
+
+        self.records: Dict[str, Any] = {
+            "on_llm_start_records": [],
+            "on_llm_token_records": [],
+            "on_llm_end_records": [],
+            "on_chain_start_records": [],
+            "on_chain_end_records": [],
+            "on_tool_start_records": [],
+            "on_tool_end_records": [],
+            "on_text_records": [],
+            "on_agent_finish_records": [],
+            "on_agent_action_records": [],
+            "on_retriever_start_records": [],
+            "on_retriever_end_records": [],
+            "action_records": [],
+        }
+
+    def _reset(self) -> None:
+        for k, v in self.metrics.items():
+            self.metrics[k] = 0
+        for k, v in self.records.items():
+            self.records[k] = []
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+        self.metrics["step"] += 1
+        self.metrics["llm_starts"] += 1
+        self.metrics["starts"] += 1
+
+        llm_starts = self.metrics["llm_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        for idx, prompt in enumerate(prompts):
+            prompt_resp = deepcopy(resp)
+            prompt_resp["prompt"] = prompt
+            self.records["on_llm_start_records"].append(prompt_resp)
+            self.records["action_records"].append(prompt_resp)
+            self.mlflg.jsonf(prompt_resp, f"llm_start_{llm_starts}_prompt_{idx}")
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+        self.metrics["step"] += 1
+        self.metrics["llm_streams"] += 1
+
+        llm_streams = self.metrics["llm_streams"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_new_token", "token": token})
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_llm_token_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"llm_new_tokens_{llm_streams}")
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.metrics["step"] += 1
+        self.metrics["llm_ends"] += 1
+        self.metrics["ends"] += 1
+
+        llm_ends = self.metrics["llm_ends"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_end"})
+        resp.update(flatten_dict(response.llm_output or {}))
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        for generations in response.generations:
+            for idx, generation in enumerate(generations):
+                generation_resp = deepcopy(resp)
+                generation_resp.update(flatten_dict(generation.dict()))
+                generation_resp.update(
+                    analyze_text(
+                        generation.text,
+                        nlp=self.nlp,
+                        textstat=self.textstat,
+                    )
+                )
+                if "text_complexity_metrics" in generation_resp:
+                    complexity_metrics: Dict[str, float] = generation_resp.pop(
+                        "text_complexity_metrics"
+                    )
+                    self.mlflg.metrics(
+                        complexity_metrics,
+                        step=self.metrics["step"],
+                    )
+                self.records["on_llm_end_records"].append(generation_resp)
+                self.records["action_records"].append(generation_resp)
+                self.mlflg.jsonf(resp, f"llm_end_{llm_ends}_generation_{idx}")
+                if "dependency_tree" in generation_resp:
+                    dependency_tree = generation_resp["dependency_tree"]
+                    self.mlflg.html(
+                        dependency_tree, "dep-" + hash_string(generation.text)
+                    )
+                if "entities" in generation_resp:
+                    entities = generation_resp["entities"]
+                    self.mlflg.html(entities, "ent-" + hash_string(generation.text))
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.metrics["step"] += 1
+        self.metrics["chain_starts"] += 1
+        self.metrics["starts"] += 1
+
+        chain_starts = self.metrics["chain_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        if isinstance(inputs, dict):
+            chain_input = ",".join([f"{k}={v}" for k, v in inputs.items()])
+        elif isinstance(inputs, list):
+            chain_input = ",".join([str(input) for input in inputs])
+        else:
+            chain_input = str(inputs)
+        input_resp = deepcopy(resp)
+        input_resp["inputs"] = chain_input
+        self.records["on_chain_start_records"].append(input_resp)
+        self.records["action_records"].append(input_resp)
+        self.mlflg.jsonf(input_resp, f"chain_start_{chain_starts}")
+
+    def on_chain_end(
+        self, outputs: Union[Dict[str, Any], str, List[str]], **kwargs: Any
+    ) -> None:
+        """Run when chain ends running."""
+        self.metrics["step"] += 1
+        self.metrics["chain_ends"] += 1
+        self.metrics["ends"] += 1
+
+        chain_ends = self.metrics["chain_ends"]
+
+        resp: Dict[str, Any] = {}
+        if isinstance(outputs, dict):
+            chain_output = ",".join([f"{k}={v}" for k, v in outputs.items()])
+        elif isinstance(outputs, list):
+            chain_output = ",".join(map(str, outputs))
+        else:
+            chain_output = str(outputs)
+        resp.update({"action": "on_chain_end", "outputs": chain_output})
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_chain_end_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"chain_end_{chain_ends}")
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.metrics["step"] += 1
+        self.metrics["tool_starts"] += 1
+        self.metrics["starts"] += 1
+
+        tool_starts = self.metrics["tool_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_start", "input_str": input_str})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_tool_start_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"tool_start_{tool_starts}")
+
+    def on_tool_end(self, output: Any, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        output = str(output)
+        self.metrics["step"] += 1
+        self.metrics["tool_ends"] += 1
+        self.metrics["ends"] += 1
+
+        tool_ends = self.metrics["tool_ends"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_end", "output": output})
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_tool_end_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"tool_end_{tool_ends}")
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when text is received.
+        """
+        self.metrics["step"] += 1
+        self.metrics["text_ctr"] += 1
+
+        text_ctr = self.metrics["text_ctr"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_text", "text": text})
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_text_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"on_text_{text_ctr}")
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.metrics["step"] += 1
+        self.metrics["agent_ends"] += 1
+        self.metrics["ends"] += 1
+
+        agent_ends = self.metrics["agent_ends"]
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_finish",
+                "output": finish.return_values["output"],
+                "log": finish.log,
+            }
+        )
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_agent_finish_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"agent_finish_{agent_ends}")
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.metrics["step"] += 1
+        self.metrics["tool_starts"] += 1
+        self.metrics["starts"] += 1
+
+        tool_starts = self.metrics["tool_starts"]
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_action",
+                "tool": action.tool,
+                "tool_input": action.tool_input,
+                "log": action.log,
+            }
+        )
+        resp.update(self.metrics)
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+        self.records["on_agent_action_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"agent_action_{tool_starts}")
+
+    def on_retriever_start(
+        self,
+        serialized: Dict[str, Any],
+        query: str,
+        **kwargs: Any,
+    ) -> Any:
+        """Run when Retriever starts running."""
+        self.metrics["step"] += 1
+        self.metrics["retriever_starts"] += 1
+        self.metrics["starts"] += 1
+
+        retriever_starts = self.metrics["retriever_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_retriever_start", "query": query})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_retriever_start_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"retriever_start_{retriever_starts}")
+
+    def on_retriever_end(
+        self,
+        documents: Sequence[Document],
+        **kwargs: Any,
+    ) -> Any:
+        """Run when Retriever ends running."""
+        self.metrics["step"] += 1
+        self.metrics["retriever_ends"] += 1
+        self.metrics["ends"] += 1
+
+        retriever_ends = self.metrics["retriever_ends"]
+
+        resp: Dict[str, Any] = {}
+        retriever_documents = [
+            {
+                "page_content": doc.page_content,
+                "metadata": {
+                    k: (
+                        str(v)
+                        if not isinstance(v, list)
+                        else ",".join(str(x) for x in v)
+                    )
+                    for k, v in doc.metadata.items()
+                },
+            }
+            for doc in documents
+        ]
+        resp.update({"action": "on_retriever_end", "documents": retriever_documents})
+        resp.update(self.metrics)
+
+        self.mlflg.metrics(self.metrics, step=self.metrics["step"])
+
+        self.records["on_retriever_end_records"].append(resp)
+        self.records["action_records"].append(resp)
+        self.mlflg.jsonf(resp, f"retriever_end_{retriever_ends}")
+
+    def on_retriever_error(self, error: BaseException, **kwargs: Any) -> Any:
+        """Run when Retriever errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def _create_session_analysis_df(self) -> Any:
+        """Create a dataframe with all the information from the session."""
+        pd = import_pandas()
+        on_llm_start_records_df = pd.DataFrame(self.records["on_llm_start_records"])
+        on_llm_end_records_df = pd.DataFrame(self.records["on_llm_end_records"])
+
+        llm_input_columns = ["step", "prompt"]
+        if "name" in on_llm_start_records_df.columns:
+            llm_input_columns.append("name")
+        elif "id" in on_llm_start_records_df.columns:
+            # id is llm class's full import path. For example:
+            # ["langchain", "llms", "openai", "AzureOpenAI"]
+            on_llm_start_records_df["name"] = on_llm_start_records_df["id"].apply(
+                lambda id_: id_[-1]
+            )
+            llm_input_columns.append("name")
+        llm_input_prompts_df = (
+            on_llm_start_records_df[llm_input_columns]
+            .dropna(axis=1)
+            .rename({"step": "prompt_step"}, axis=1)
+        )
+        complexity_metrics_columns = (
+            get_text_complexity_metrics() if self.textstat is not None else []
+        )
+        visualizations_columns = (
+            ["dependency_tree", "entities"] if self.nlp is not None else []
+        )
+
+        token_usage_columns = [
+            "token_usage_total_tokens",
+            "token_usage_prompt_tokens",
+            "token_usage_completion_tokens",
+        ]
+        token_usage_columns = [
+            x for x in token_usage_columns if x in on_llm_end_records_df.columns
+        ]
+
+        llm_outputs_df = (
+            on_llm_end_records_df[
+                [
+                    "step",
+                    "text",
+                ]
+                + token_usage_columns
+                + complexity_metrics_columns
+                + visualizations_columns
+            ]
+            .dropna(axis=1)
+            .rename({"step": "output_step", "text": "output"}, axis=1)
+        )
+        session_analysis_df = pd.concat([llm_input_prompts_df, llm_outputs_df], axis=1)
+        session_analysis_df["chat_html"] = session_analysis_df[
+            ["prompt", "output"]
+        ].apply(
+            lambda row: construct_html_from_prompt_and_generation(
+                row["prompt"], row["output"]
+            ),
+            axis=1,
+        )
+        return session_analysis_df
+
+    def _contain_llm_records(self) -> bool:
+        return bool(self.records["on_llm_start_records"])
+
+    def flush_tracker(self, langchain_asset: Any = None, finish: bool = False) -> None:
+        pd = import_pandas()
+        self.mlflg.table("action_records", pd.DataFrame(self.records["action_records"]))
+        if self._contain_llm_records():
+            session_analysis_df = self._create_session_analysis_df()
+            chat_html = session_analysis_df.pop("chat_html")
+            chat_html = chat_html.replace("\n", "", regex=True)
+            self.mlflg.table("session_analysis", pd.DataFrame(session_analysis_df))
+            self.mlflg.html("".join(chat_html.tolist()), "chat_html")
+
+        if langchain_asset:
+            # To avoid circular import error
+            # mlflow only supports LLMChain asset
+            if "langchain.chains.llm.LLMChain" in str(type(langchain_asset)):
+                self.mlflg.langchain_artifact(langchain_asset)
+            else:
+                langchain_asset_path = str(Path(self.temp_dir.name, "model.json"))
+                try:
+                    langchain_asset.save(langchain_asset_path)
+                    self.mlflg.artifact(langchain_asset_path)
+                except ValueError:
+                    try:
+                        langchain_asset.save_agent(langchain_asset_path)
+                        self.mlflg.artifact(langchain_asset_path)
+                    except AttributeError:
+                        print("Could not save model.")  # noqa: T201
+                        traceback.print_exc()
+                        pass
+                    except NotImplementedError:
+                        print("Could not save model.")  # noqa: T201
+                        traceback.print_exc()
+                        pass
+                except NotImplementedError:
+                    print("Could not save model.")  # noqa: T201
+                    traceback.print_exc()
+                    pass
+        if finish:
+            self.mlflg.finish_run()
+            self._reset()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/openai_info.py

@@ -0,0 +1,555 @@
+"""Callback Handler that prints to std out."""
+
+import threading
+from enum import Enum, auto
+from typing import Any, Dict, List
+
+from langchain_core._api import warn_deprecated
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import AIMessage
+from langchain_core.outputs import ChatGeneration, LLMResult
+
+MODEL_COST_PER_1K_TOKENS = {
+    # GPT-5 input
+    "gpt-5": 0.00125,
+    "gpt-5-cached": 0.000125,
+    "gpt-5-2025-08-07": 0.00125,
+    "gpt-5-2025-08-07-cached": 0.000125,
+    # GPT-5 output
+    "gpt-5-completion": 0.01,
+    "gpt-5-2025-08-07-completion": 0.01,
+    # GPT-5-mini input
+    "gpt-5-mini": 0.00025,
+    "gpt-5-mini-cached": 0.000025,
+    "gpt-5-mini-2025-08-07": 0.00025,
+    "gpt-5-mini-2025-08-07-cached": 0.000025,
+    # GPT-5-mini output
+    "gpt-5-mini-completion": 0.002,
+    "gpt-5-mini-2025-08-07-completion": 0.002,
+    # GPT-5-nano input
+    "gpt-5-nano": 0.00005,
+    "gpt-5-nano-cached": 0.000005,
+    "gpt-5-nano-2025-08-07": 0.00005,
+    "gpt-5-nano-2025-08-07-cached": 0.000005,
+    # GPT-5-nano output
+    "gpt-5-nano-completion": 0.0004,
+    "gpt-5-nano-2025-08-07-completion": 0.0004,
+    # GPT-5-chat-latest input
+    "gpt-5-chat-latest": 0.00125,
+    "gpt-5-chat-latest-cached": 0.000125,
+    "gpt-5-chat-latest-2025-08-07": 0.00125,
+    "gpt-5-chat-latest-2025-08-07-cached": 0.000125,
+    # GPT-5-chat-latest output
+    "gpt-5-chat-latest-completion": 0.01,
+    "gpt-5-chat-latest-2025-08-07-completion": 0.01,
+    # GPT-4.1 input
+    "gpt-4.1": 0.002,
+    "gpt-4.1-2025-04-14": 0.002,
+    "gpt-4.1-cached": 0.0005,
+    "gpt-4.1-2025-04-14-cached": 0.0005,
+    # GPT-4.1 output
+    "gpt-4.1-completion": 0.008,
+    "gpt-4.1-2025-04-14-completion": 0.008,
+    # GPT-4.1-mini input
+    "gpt-4.1-mini": 0.0004,
+    "gpt-4.1-mini-2025-04-14": 0.0004,
+    "gpt-4.1-mini-cached": 0.0001,
+    "gpt-4.1-mini-2025-04-14-cached": 0.0001,
+    # GPT-4.1-mini output
+    "gpt-4.1-mini-completion": 0.0016,
+    "gpt-4.1-mini-2025-04-14-completion": 0.0016,
+    # GPT-4.1-nano input
+    "gpt-4.1-nano": 0.0001,
+    "gpt-4.1-nano-2025-04-14": 0.0001,
+    "gpt-4.1-nano-cached": 0.000025,
+    "gpt-4.1-nano-2025-04-14-cached": 0.000025,
+    # GPT-4.1-nano output
+    "gpt-4.1-nano-completion": 0.0004,
+    "gpt-4.1-nano-2025-04-14-completion": 0.0004,
+    # GPT-4.5-preview input
+    "gpt-4.5-preview": 0.075,
+    "gpt-4.5-preview-2025-02-27": 0.075,
+    "gpt-4.5-preview-cached": 0.0375,
+    "gpt-4.5-preview-2025-02-27-cached": 0.0375,
+    # GPT-4.5-preview output
+    "gpt-4.5-preview-completion": 0.15,
+    "gpt-4.5-preview-2025-02-27-completion": 0.15,
+    # OpenAI o1 input
+    "o1": 0.015,
+    "o1-2024-12-17": 0.015,
+    "o1-cached": 0.0075,
+    "o1-2024-12-17-cached": 0.0075,
+    # OpenAI o1 output
+    "o1-completion": 0.06,
+    "o1-2024-12-17-completion": 0.06,
+    # OpenAI o1-pro input
+    "o1-pro": 0.15,
+    "o1-pro-2025-03-19": 0.15,
+    # OpenAI o1-pro output
+    "o1-pro-completion": 0.6,
+    "o1-pro-2025-03-19-completion": 0.6,
+    # OpenAI o3 input
+    "o3": 0.002,
+    "o3-2025-04-16": 0.002,
+    "o3-cached": 0.0005,
+    "o3-2025-04-16-cached": 0.0005,
+    # OpenAI o3 output
+    "o3-completion": 0.008,
+    "o3-2025-04-16-completion": 0.008,
+    # OpenAI o4-mini input
+    "o4-mini": 0.0011,
+    "o4-mini-2025-04-16": 0.0011,
+    "o4-mini-cached": 0.000275,
+    "o4-mini-2025-04-16-cached": 0.000275,
+    # OpenAI o4-mini output
+    "o4-mini-completion": 0.0044,
+    "o4-mini-2025-04-16-completion": 0.0044,
+    # OpenAI o3-mini input
+    "o3-mini": 0.0011,
+    "o3-mini-2025-01-31": 0.0011,
+    "o3-mini-cached": 0.00055,
+    "o3-mini-2025-01-31-cached": 0.00055,
+    # OpenAI o3-mini output
+    "o3-mini-completion": 0.0044,
+    "o3-mini-2025-01-31-completion": 0.0044,
+    # OpenAI o1-mini input (updated pricing)
+    "o1-mini": 0.0011,
+    "o1-mini-cached": 0.00055,
+    "o1-mini-2024-09-12": 0.0011,
+    "o1-mini-2024-09-12-cached": 0.00055,
+    # OpenAI o1-mini output (updated pricing)
+    "o1-mini-completion": 0.0044,
+    "o1-mini-2024-09-12-completion": 0.0044,
+    # OpenAI o1-preview input
+    "o1-preview": 0.015,
+    "o1-preview-cached": 0.0075,
+    "o1-preview-2024-09-12": 0.015,
+    "o1-preview-2024-09-12-cached": 0.0075,
+    # OpenAI o1-preview output
+    "o1-preview-completion": 0.06,
+    "o1-preview-2024-09-12-completion": 0.06,
+    # GPT-4o input
+    "gpt-4o": 0.0025,
+    "gpt-4o-cached": 0.00125,
+    "gpt-4o-2024-05-13": 0.005,
+    "gpt-4o-2024-08-06": 0.0025,
+    "gpt-4o-2024-08-06-cached": 0.00125,
+    "gpt-4o-2024-11-20": 0.0025,
+    "gpt-4o-2024-11-20-cached": 0.00125,
+    # GPT-4o output
+    "gpt-4o-completion": 0.01,
+    "gpt-4o-2024-05-13-completion": 0.015,
+    "gpt-4o-2024-08-06-completion": 0.01,
+    "gpt-4o-2024-11-20-completion": 0.01,
+    # GPT-4o-audio-preview input
+    "gpt-4o-audio-preview": 0.0025,
+    "gpt-4o-audio-preview-2024-12-17": 0.0025,
+    "gpt-4o-audio-preview-2024-10-01": 0.0025,
+    # GPT-4o-audio-preview output
+    "gpt-4o-audio-preview-completion": 0.01,
+    "gpt-4o-audio-preview-2024-12-17-completion": 0.01,
+    "gpt-4o-audio-preview-2024-10-01-completion": 0.01,
+    # GPT-4o-realtime-preview input
+    "gpt-4o-realtime-preview": 0.005,
+    "gpt-4o-realtime-preview-2024-12-17": 0.005,
+    "gpt-4o-realtime-preview-2024-10-01": 0.005,
+    "gpt-4o-realtime-preview-cached": 0.0025,
+    "gpt-4o-realtime-preview-2024-12-17-cached": 0.0025,
+    "gpt-4o-realtime-preview-2024-10-01-cached": 0.0025,
+    # GPT-4o-realtime-preview output
+    "gpt-4o-realtime-preview-completion": 0.02,
+    "gpt-4o-realtime-preview-2024-12-17-completion": 0.02,
+    "gpt-4o-realtime-preview-2024-10-01-completion": 0.02,
+    # GPT-4o-mini input
+    "gpt-4o-mini": 0.00015,
+    "gpt-4o-mini-cached": 0.000075,
+    "gpt-4o-mini-2024-07-18": 0.00015,
+    "gpt-4o-mini-2024-07-18-cached": 0.000075,
+    # GPT-4o-mini output
+    "gpt-4o-mini-completion": 0.0006,
+    "gpt-4o-mini-2024-07-18-completion": 0.0006,
+    # GPT-4o-mini-audio-preview input
+    "gpt-4o-mini-audio-preview": 0.00015,
+    "gpt-4o-mini-audio-preview-2024-12-17": 0.00015,
+    # GPT-4o-mini-audio-preview output
+    "gpt-4o-mini-audio-preview-completion": 0.0006,
+    "gpt-4o-mini-audio-preview-2024-12-17-completion": 0.0006,
+    # GPT-4o-mini-realtime-preview input
+    "gpt-4o-mini-realtime-preview": 0.0006,
+    "gpt-4o-mini-realtime-preview-2024-12-17": 0.0006,
+    "gpt-4o-mini-realtime-preview-cached": 0.0003,
+    "gpt-4o-mini-realtime-preview-2024-12-17-cached": 0.0003,
+    # GPT-4o-mini-realtime-preview output
+    "gpt-4o-mini-realtime-preview-completion": 0.0024,
+    "gpt-4o-mini-realtime-preview-2024-12-17-completion": 0.0024,
+    # GPT-4o-mini-search-preview input
+    "gpt-4o-mini-search-preview": 0.00015,
+    "gpt-4o-mini-search-preview-2025-03-11": 0.00015,
+    # GPT-4o-mini-search-preview output
+    "gpt-4o-mini-search-preview-completion": 0.0006,
+    "gpt-4o-mini-search-preview-2025-03-11-completion": 0.0006,
+    # GPT-4o-search-preview input
+    "gpt-4o-search-preview": 0.0025,
+    "gpt-4o-search-preview-2025-03-11": 0.0025,
+    # GPT-4o-search-preview output
+    "gpt-4o-search-preview-completion": 0.01,
+    "gpt-4o-search-preview-2025-03-11-completion": 0.01,
+    # Computer-use-preview input
+    "computer-use-preview": 0.003,
+    "computer-use-preview-2025-03-11": 0.003,
+    # Computer-use-preview output
+    "computer-use-preview-completion": 0.012,
+    "computer-use-preview-2025-03-11-completion": 0.012,
+    # GPT-4 input
+    "gpt-4": 0.03,
+    "gpt-4-0314": 0.03,
+    "gpt-4-0613": 0.03,
+    "gpt-4-32k": 0.06,
+    "gpt-4-32k-0314": 0.06,
+    "gpt-4-32k-0613": 0.06,
+    "gpt-4-vision-preview": 0.01,
+    "gpt-4-1106-preview": 0.01,
+    "gpt-4-0125-preview": 0.01,
+    "gpt-4-turbo-preview": 0.01,
+    "gpt-4-turbo": 0.01,
+    "gpt-4-turbo-2024-04-09": 0.01,
+    # GPT-4 output
+    "gpt-4-completion": 0.06,
+    "gpt-4-0314-completion": 0.06,
+    "gpt-4-0613-completion": 0.06,
+    "gpt-4-32k-completion": 0.12,
+    "gpt-4-32k-0314-completion": 0.12,
+    "gpt-4-32k-0613-completion": 0.12,
+    "gpt-4-vision-preview-completion": 0.03,
+    "gpt-4-1106-preview-completion": 0.03,
+    "gpt-4-0125-preview-completion": 0.03,
+    "gpt-4-turbo-preview-completion": 0.03,
+    "gpt-4-turbo-completion": 0.03,
+    "gpt-4-turbo-2024-04-09-completion": 0.03,
+    # GPT-3.5 input
+    # gpt-3.5-turbo points at gpt-3.5-turbo-0613 until Feb 16, 2024.
+    # Switches to gpt-3.5-turbo-0125 after.
+    "gpt-3.5-turbo": 0.0015,
+    "gpt-3.5-turbo-0125": 0.0005,
+    "gpt-3.5-turbo-0301": 0.0015,
+    "gpt-3.5-turbo-0613": 0.0015,
+    "gpt-3.5-turbo-1106": 0.001,
+    "gpt-3.5-turbo-instruct": 0.0015,
+    "gpt-3.5-turbo-16k": 0.003,
+    "gpt-3.5-turbo-16k-0613": 0.003,
+    # GPT-3.5 output
+    # gpt-3.5-turbo points at gpt-3.5-turbo-0613 until Feb 16, 2024.
+    # Switches to gpt-3.5-turbo-0125 after.
+    "gpt-3.5-turbo-completion": 0.002,
+    "gpt-3.5-turbo-0125-completion": 0.0015,
+    "gpt-3.5-turbo-0301-completion": 0.002,
+    "gpt-3.5-turbo-0613-completion": 0.002,
+    "gpt-3.5-turbo-1106-completion": 0.002,
+    "gpt-3.5-turbo-instruct-completion": 0.002,
+    "gpt-3.5-turbo-16k-completion": 0.004,
+    "gpt-3.5-turbo-16k-0613-completion": 0.004,
+    # Azure GPT-35 input
+    "gpt-35-turbo": 0.0015,  # Azure OpenAI version of ChatGPT
+    "gpt-35-turbo-0125": 0.0005,
+    "gpt-35-turbo-0301": 0.002,  # Azure OpenAI version of ChatGPT
+    "gpt-35-turbo-0613": 0.0015,
+    "gpt-35-turbo-instruct": 0.0015,
+    "gpt-35-turbo-16k": 0.003,
+    "gpt-35-turbo-16k-0613": 0.003,
+    # Azure GPT-35 output
+    "gpt-35-turbo-completion": 0.002,  # Azure OpenAI version of ChatGPT
+    "gpt-35-turbo-0125-completion": 0.0015,
+    "gpt-35-turbo-0301-completion": 0.002,  # Azure OpenAI version of ChatGPT
+    "gpt-35-turbo-0613-completion": 0.002,
+    "gpt-35-turbo-instruct-completion": 0.002,
+    "gpt-35-turbo-16k-completion": 0.004,
+    "gpt-35-turbo-16k-0613-completion": 0.004,
+    # Others
+    "text-ada-001": 0.0004,
+    "ada": 0.0004,
+    "text-babbage-001": 0.0005,
+    "babbage": 0.0005,
+    "text-curie-001": 0.002,
+    "curie": 0.002,
+    "text-davinci-003": 0.02,
+    "text-davinci-002": 0.02,
+    "code-davinci-002": 0.02,
+    # Fine Tuned input
+    "babbage-002-finetuned": 0.0016,
+    "davinci-002-finetuned": 0.012,
+    "gpt-3.5-turbo-0613-finetuned": 0.003,
+    "gpt-3.5-turbo-1106-finetuned": 0.003,
+    "gpt-3.5-turbo-0125-finetuned": 0.003,
+    "gpt-4o-mini-2024-07-18-finetuned": 0.0003,
+    "gpt-4o-mini-2024-07-18-finetuned-cached": 0.00015,
+    # Fine Tuned output
+    "babbage-002-finetuned-completion": 0.0016,
+    "davinci-002-finetuned-completion": 0.012,
+    "gpt-3.5-turbo-0613-finetuned-completion": 0.006,
+    "gpt-3.5-turbo-1106-finetuned-completion": 0.006,
+    "gpt-3.5-turbo-0125-finetuned-completion": 0.006,
+    "gpt-4o-mini-2024-07-18-finetuned-completion": 0.0012,
+    # Azure Fine Tuned input
+    "babbage-002-azure-finetuned": 0.0004,
+    "davinci-002-azure-finetuned": 0.002,
+    "gpt-35-turbo-0613-azure-finetuned": 0.0015,
+    # Azure Fine Tuned output
+    "babbage-002-azure-finetuned-completion": 0.0004,
+    "davinci-002-azure-finetuned-completion": 0.002,
+    "gpt-35-turbo-0613-azure-finetuned-completion": 0.002,
+    # Legacy fine-tuned models
+    "ada-finetuned-legacy": 0.0016,
+    "babbage-finetuned-legacy": 0.0024,
+    "curie-finetuned-legacy": 0.012,
+    "davinci-finetuned-legacy": 0.12,
+}
+
+
+class TokenType(Enum):
+    """Token type enum."""
+
+    PROMPT = auto()
+    PROMPT_CACHED = auto()
+    COMPLETION = auto()
+
+
+def standardize_model_name(
+    model_name: str,
+    is_completion: bool = False,
+    *,
+    token_type: TokenType = TokenType.PROMPT,
+) -> str:
+    """
+    Standardize the model name to a format that can be used in the OpenAI API.
+
+    Args:
+        model_name: Model name to standardize.
+        is_completion: Whether the model is used for completion or not.
+            Defaults to False. Deprecated in favor of ``token_type``.
+        token_type: Token type. Defaults to ``TokenType.PROMPT``.
+
+    Returns:
+        Standardized model name.
+
+    """
+    if is_completion:
+        warn_deprecated(
+            since="0.3.13",
+            message=(
+                "is_completion is deprecated. Use token_type instead. Example:\n\n"
+                "from langchain_community.callbacks.openai_info import TokenType\n\n"
+                "standardize_model_name('gpt-4o', token_type=TokenType.COMPLETION)\n"
+            ),
+            removal="1.0",
+        )
+        token_type = TokenType.COMPLETION
+    model_name = model_name.lower()
+    if ".ft-" in model_name:
+        model_name = model_name.split(".ft-")[0] + "-azure-finetuned"
+    if ":ft-" in model_name:
+        model_name = model_name.split(":")[0] + "-finetuned-legacy"
+    if "ft:" in model_name:
+        model_name = model_name.split(":")[1] + "-finetuned"
+    if token_type == TokenType.COMPLETION and (
+        model_name.startswith("gpt-5")
+        or model_name.startswith("gpt-4")
+        or model_name.startswith("gpt-3.5")
+        or model_name.startswith("gpt-35")
+        or model_name.startswith("o1-")
+        or model_name.startswith("o3-")
+        or model_name.startswith("o4-")
+        or ("finetuned" in model_name and "legacy" not in model_name)
+    ):
+        return model_name + "-completion"
+    if (
+        token_type == TokenType.PROMPT_CACHED
+        and (
+            model_name.startswith("gpt-5")
+            or model_name.startswith("gpt-4o")
+            or model_name.startswith("gpt-4.1")
+            or model_name.startswith("o1")
+            or model_name.startswith("o3")
+            or model_name.startswith("o4")
+        )
+        and not (model_name.startswith("gpt-4o-2024-05-13"))
+    ):
+        return model_name + "-cached"
+    else:
+        return model_name
+
+
+def get_openai_token_cost_for_model(
+    model_name: str,
+    num_tokens: int,
+    is_completion: bool = False,
+    *,
+    token_type: TokenType = TokenType.PROMPT,
+) -> float:
+    """
+    Get the cost in USD for a given model and number of tokens.
+
+    Args:
+        model_name: Name of the model
+        num_tokens: Number of tokens.
+        is_completion: Whether the model is used for completion or not.
+            Defaults to False. Deprecated in favor of ``token_type``.
+        token_type: Token type. Defaults to ``TokenType.PROMPT``.
+
+    Returns:
+        Cost in USD.
+    """
+    if is_completion:
+        warn_deprecated(
+            since="0.3.13",
+            message=(
+                "is_completion is deprecated. Use token_type instead. Example:\n\n"
+                "from langchain_community.callbacks.openai_info import TokenType\n\n"
+                "get_openai_token_cost_for_model('gpt-4o', 10, token_type=TokenType.COMPLETION)\n"  # noqa: E501
+            ),
+            removal="1.0",
+        )
+        token_type = TokenType.COMPLETION
+    model_name = standardize_model_name(model_name, token_type=token_type)
+    if model_name not in MODEL_COST_PER_1K_TOKENS:
+        raise ValueError(
+            f"Unknown model: {model_name}. Please provide a valid OpenAI model name."
+            "Known models are: " + ", ".join(MODEL_COST_PER_1K_TOKENS.keys())
+        )
+    return MODEL_COST_PER_1K_TOKENS[model_name] * (num_tokens / 1000)
+
+
+class OpenAICallbackHandler(BaseCallbackHandler):
+    """Callback Handler that tracks OpenAI info."""
+
+    total_tokens: int = 0
+    prompt_tokens: int = 0
+    prompt_tokens_cached: int = 0
+    completion_tokens: int = 0
+    reasoning_tokens: int = 0
+    successful_requests: int = 0
+    total_cost: float = 0.0
+
+    def __init__(self) -> None:
+        super().__init__()
+        self._lock = threading.Lock()
+
+    def __repr__(self) -> str:
+        return (
+            f"Tokens Used: {self.total_tokens}\n"
+            f"\tPrompt Tokens: {self.prompt_tokens}\n"
+            f"\t\tPrompt Tokens Cached: {self.prompt_tokens_cached}\n"
+            f"\tCompletion Tokens: {self.completion_tokens}\n"
+            f"\t\tReasoning Tokens: {self.reasoning_tokens}\n"
+            f"Successful Requests: {self.successful_requests}\n"
+            f"Total Cost (USD): ${self.total_cost}"
+        )
+
+    @property
+    def always_verbose(self) -> bool:
+        """Whether to call verbose callbacks even if verbose is False."""
+        return True
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Print out the prompts."""
+        pass
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Print out the token."""
+        pass
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Collect token usage."""
+        # Check for usage_metadata (langchain-core >= 0.2.2)
+        try:
+            generation = response.generations[0][0]
+        except IndexError:
+            generation = None
+        if isinstance(generation, ChatGeneration):
+            try:
+                message = generation.message
+                if isinstance(message, AIMessage):
+                    usage_metadata = message.usage_metadata
+                    response_metadata = message.response_metadata
+                else:
+                    usage_metadata = None
+                    response_metadata = None
+            except AttributeError:
+                usage_metadata = None
+                response_metadata = None
+        else:
+            usage_metadata = None
+            response_metadata = None
+
+        prompt_tokens_cached = 0
+        reasoning_tokens = 0
+
+        if usage_metadata:
+            token_usage = {"total_tokens": usage_metadata["total_tokens"]}
+            completion_tokens = usage_metadata["output_tokens"]
+            prompt_tokens = usage_metadata["input_tokens"]
+            if response_model_name := (response_metadata or {}).get("model_name"):
+                model_name = standardize_model_name(response_model_name)
+            elif response.llm_output is None:
+                model_name = ""
+            else:
+                model_name = standardize_model_name(
+                    response.llm_output.get("model_name", "")
+                )
+            if "cache_read" in usage_metadata.get("input_token_details", {}):
+                prompt_tokens_cached = usage_metadata["input_token_details"][
+                    "cache_read"
+                ]
+            if "reasoning" in usage_metadata.get("output_token_details", {}):
+                reasoning_tokens = usage_metadata["output_token_details"]["reasoning"]
+        else:
+            if response.llm_output is None:
+                return None
+
+            if "token_usage" not in response.llm_output:
+                with self._lock:
+                    self.successful_requests += 1
+                return None
+
+            # compute tokens and cost for this request
+            token_usage = response.llm_output["token_usage"]
+            completion_tokens = token_usage.get("completion_tokens", 0)
+            prompt_tokens = token_usage.get("prompt_tokens", 0)
+            model_name = standardize_model_name(
+                response.llm_output.get("model_name", "")
+            )
+
+        if model_name in MODEL_COST_PER_1K_TOKENS:
+            uncached_prompt_tokens = prompt_tokens - prompt_tokens_cached
+            uncached_prompt_cost = get_openai_token_cost_for_model(
+                model_name, uncached_prompt_tokens, token_type=TokenType.PROMPT
+            )
+            cached_prompt_cost = get_openai_token_cost_for_model(
+                model_name, prompt_tokens_cached, token_type=TokenType.PROMPT_CACHED
+            )
+            prompt_cost = uncached_prompt_cost + cached_prompt_cost
+            completion_cost = get_openai_token_cost_for_model(
+                model_name, completion_tokens, token_type=TokenType.COMPLETION
+            )
+        else:
+            completion_cost = 0
+            prompt_cost = 0
+
+        # update shared state behind lock
+        with self._lock:
+            self.total_cost += prompt_cost + completion_cost
+            self.total_tokens += token_usage.get("total_tokens", 0)
+            self.prompt_tokens += prompt_tokens
+            self.prompt_tokens_cached += prompt_tokens_cached
+            self.completion_tokens += completion_tokens
+            self.reasoning_tokens += reasoning_tokens
+            self.successful_requests += 1
+
+    def __copy__(self) -> "OpenAICallbackHandler":
+        """Return a copy of the callback handler."""
+        return self
+
+    def __deepcopy__(self, memo: Any) -> "OpenAICallbackHandler":
+        """Return a deep copy of the callback handler."""
+        return self

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/promptlayer_callback.py

@@ -0,0 +1,163 @@
+"""Callback handler for promptlayer."""
+
+from __future__ import annotations
+
+import datetime
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    ChatMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from langchain_core.outputs import (
+    ChatGeneration,
+    LLMResult,
+)
+
+if TYPE_CHECKING:
+    import promptlayer
+
+
+def _lazy_import_promptlayer() -> promptlayer:
+    """Lazy import promptlayer to avoid circular imports."""
+    try:
+        import promptlayer
+    except ImportError:
+        raise ImportError(
+            "The PromptLayerCallbackHandler requires the promptlayer package. "
+            " Please install it with `pip install promptlayer`."
+        )
+    return promptlayer
+
+
+class PromptLayerCallbackHandler(BaseCallbackHandler):
+    """Callback handler for promptlayer."""
+
+    def __init__(
+        self,
+        pl_id_callback: Optional[Callable[..., Any]] = None,
+        pl_tags: Optional[List[str]] = None,
+    ) -> None:
+        """Initialize the PromptLayerCallbackHandler."""
+        _lazy_import_promptlayer()
+        self.pl_id_callback = pl_id_callback
+        self.pl_tags = pl_tags or []
+        self.runs: Dict[UUID, Dict[str, Any]] = {}
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        self.runs[run_id] = {
+            "messages": [self._create_message_dicts(m)[0] for m in messages],
+            "invocation_params": kwargs.get("invocation_params", {}),
+            "name": ".".join(serialized["id"]),
+            "request_start_time": datetime.datetime.now().timestamp(),
+            "tags": tags,
+        }
+
+    def on_llm_start(
+        self,
+        serialized: Dict[str, Any],
+        prompts: List[str],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> Any:
+        self.runs[run_id] = {
+            "prompts": prompts,
+            "invocation_params": kwargs.get("invocation_params", {}),
+            "name": ".".join(serialized["id"]),
+            "request_start_time": datetime.datetime.now().timestamp(),
+            "tags": tags,
+        }
+
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        from promptlayer.utils import get_api_key, promptlayer_api_request
+
+        run_info = self.runs.get(run_id, {})
+        if not run_info:
+            return
+        run_info["request_end_time"] = datetime.datetime.now().timestamp()
+        for i in range(len(response.generations)):
+            generation = response.generations[i][0]
+
+            resp = {
+                "text": generation.text,
+                "llm_output": response.llm_output,
+            }
+            model_params = run_info.get("invocation_params", {})
+            is_chat_model = run_info.get("messages", None) is not None
+            model_input = (
+                run_info.get("messages", [])[i]
+                if is_chat_model
+                else [run_info.get("prompts", [])[i]]
+            )
+            model_response = (
+                [self._convert_message_to_dict(generation.message)]
+                if is_chat_model and isinstance(generation, ChatGeneration)
+                else resp
+            )
+
+            pl_request_id = promptlayer_api_request(
+                run_info.get("name"),
+                "langchain",
+                model_input,
+                model_params,
+                self.pl_tags,
+                model_response,
+                run_info.get("request_start_time"),
+                run_info.get("request_end_time"),
+                get_api_key(),
+                return_pl_id=bool(self.pl_id_callback is not None),
+                metadata={
+                    "_langchain_run_id": str(run_id),
+                    "_langchain_parent_run_id": str(parent_run_id),
+                    "_langchain_tags": str(run_info.get("tags", [])),
+                },
+            )
+
+            if self.pl_id_callback:
+                self.pl_id_callback(pl_request_id)
+
+    def _convert_message_to_dict(self, message: BaseMessage) -> Dict[str, Any]:
+        if isinstance(message, HumanMessage):
+            message_dict = {"role": "user", "content": message.content}
+        elif isinstance(message, AIMessage):
+            message_dict = {"role": "assistant", "content": message.content}
+        elif isinstance(message, SystemMessage):
+            message_dict = {"role": "system", "content": message.content}
+        elif isinstance(message, ChatMessage):
+            message_dict = {"role": message.role, "content": message.content}
+        else:
+            raise ValueError(f"Got unknown type {message}")
+        if "name" in message.additional_kwargs:
+            message_dict["name"] = message.additional_kwargs["name"]
+        return message_dict
+
+    def _create_message_dicts(
+        self, messages: List[BaseMessage]
+    ) -> Tuple[List[Dict[str, Any]], Dict[str, Any]]:
+        params: Dict[str, Any] = {}
+        message_dicts = [self._convert_message_to_dict(m) for m in messages]
+        return message_dicts, params

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/sagemaker_callback.py

@@ -0,0 +1,277 @@
+import json
+import os
+import shutil
+import tempfile
+from copy import deepcopy
+from typing import Any, Dict, List, Optional
+
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+
+from langchain_community.callbacks.utils import (
+    flatten_dict,
+)
+
+
+def save_json(data: dict, file_path: str) -> None:
+    """Save dict to local file path.
+
+    Parameters:
+        data (dict): The dictionary to be saved.
+        file_path (str): Local file path.
+    """
+    with open(file_path, "w") as outfile:
+        json.dump(data, outfile)
+
+
+class SageMakerCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs prompt artifacts and metrics to SageMaker Experiments.
+
+    Parameters:
+        run (sagemaker.experiments.run.Run): Run object where the experiment is logged.
+    """
+
+    def __init__(self, run: Any) -> None:
+        """Initialize callback handler."""
+        super().__init__()
+
+        self.run = run
+
+        self.metrics = {
+            "step": 0,
+            "starts": 0,
+            "ends": 0,
+            "errors": 0,
+            "text_ctr": 0,
+            "chain_starts": 0,
+            "chain_ends": 0,
+            "llm_starts": 0,
+            "llm_ends": 0,
+            "llm_streams": 0,
+            "tool_starts": 0,
+            "tool_ends": 0,
+            "agent_ends": 0,
+        }
+
+        # Create a temporary directory
+        self.temp_dir = tempfile.mkdtemp()
+
+    def _reset(self) -> None:
+        for k, v in self.metrics.items():
+            self.metrics[k] = 0
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+        self.metrics["step"] += 1
+        self.metrics["llm_starts"] += 1
+        self.metrics["starts"] += 1
+
+        llm_starts = self.metrics["llm_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        for idx, prompt in enumerate(prompts):
+            prompt_resp = deepcopy(resp)
+            prompt_resp["prompt"] = prompt
+            self.jsonf(
+                prompt_resp,
+                self.temp_dir,
+                f"llm_start_{llm_starts}_prompt_{idx}",
+            )
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+        self.metrics["step"] += 1
+        self.metrics["llm_streams"] += 1
+
+        llm_streams = self.metrics["llm_streams"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_new_token", "token": token})
+        resp.update(self.metrics)
+
+        self.jsonf(resp, self.temp_dir, f"llm_new_tokens_{llm_streams}")
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.metrics["step"] += 1
+        self.metrics["llm_ends"] += 1
+        self.metrics["ends"] += 1
+
+        llm_ends = self.metrics["llm_ends"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_llm_end"})
+        resp.update(flatten_dict(response.llm_output or {}))
+
+        resp.update(self.metrics)
+
+        for generations in response.generations:
+            for idx, generation in enumerate(generations):
+                generation_resp = deepcopy(resp)
+                generation_resp.update(flatten_dict(generation.dict()))
+
+                self.jsonf(
+                    resp,
+                    self.temp_dir,
+                    f"llm_end_{llm_ends}_generation_{idx}",
+                )
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.metrics["step"] += 1
+        self.metrics["chain_starts"] += 1
+        self.metrics["starts"] += 1
+
+        chain_starts = self.metrics["chain_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        chain_input = ",".join([f"{k}={v}" for k, v in inputs.items()])
+        input_resp = deepcopy(resp)
+        input_resp["inputs"] = chain_input
+
+        self.jsonf(input_resp, self.temp_dir, f"chain_start_{chain_starts}")
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        self.metrics["step"] += 1
+        self.metrics["chain_ends"] += 1
+        self.metrics["ends"] += 1
+
+        chain_ends = self.metrics["chain_ends"]
+
+        resp: Dict[str, Any] = {}
+        chain_output = ",".join([f"{k}={v}" for k, v in outputs.items()])
+        resp.update({"action": "on_chain_end", "outputs": chain_output})
+        resp.update(self.metrics)
+
+        self.jsonf(resp, self.temp_dir, f"chain_end_{chain_ends}")
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.metrics["step"] += 1
+        self.metrics["tool_starts"] += 1
+        self.metrics["starts"] += 1
+
+        tool_starts = self.metrics["tool_starts"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_start", "input_str": input_str})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.metrics)
+
+        self.jsonf(resp, self.temp_dir, f"tool_start_{tool_starts}")
+
+    def on_tool_end(self, output: Any, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        output = str(output)
+        self.metrics["step"] += 1
+        self.metrics["tool_ends"] += 1
+        self.metrics["ends"] += 1
+
+        tool_ends = self.metrics["tool_ends"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_tool_end", "output": output})
+        resp.update(self.metrics)
+
+        self.jsonf(resp, self.temp_dir, f"tool_end_{tool_ends}")
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.metrics["step"] += 1
+        self.metrics["errors"] += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.metrics["step"] += 1
+        self.metrics["text_ctr"] += 1
+
+        text_ctr = self.metrics["text_ctr"]
+
+        resp: Dict[str, Any] = {}
+        resp.update({"action": "on_text", "text": text})
+        resp.update(self.metrics)
+
+        self.jsonf(resp, self.temp_dir, f"on_text_{text_ctr}")
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.metrics["step"] += 1
+        self.metrics["agent_ends"] += 1
+        self.metrics["ends"] += 1
+
+        agent_ends = self.metrics["agent_ends"]
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_finish",
+                "output": finish.return_values["output"],
+                "log": finish.log,
+            }
+        )
+        resp.update(self.metrics)
+
+        self.jsonf(resp, self.temp_dir, f"agent_finish_{agent_ends}")
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.metrics["step"] += 1
+        self.metrics["tool_starts"] += 1
+        self.metrics["starts"] += 1
+
+        tool_starts = self.metrics["tool_starts"]
+        resp: Dict[str, Any] = {}
+        resp.update(
+            {
+                "action": "on_agent_action",
+                "tool": action.tool,
+                "tool_input": action.tool_input,
+                "log": action.log,
+            }
+        )
+        resp.update(self.metrics)
+        self.jsonf(resp, self.temp_dir, f"agent_action_{tool_starts}")
+
+    def jsonf(
+        self,
+        data: Dict[str, Any],
+        data_dir: str,
+        filename: str,
+        is_output: Optional[bool] = True,
+    ) -> None:
+        """To log the input data as json file artifact."""
+        file_path = os.path.join(data_dir, f"{filename}.json")
+        save_json(data, file_path)
+        self.run.log_file(file_path, name=filename, is_output=is_output)
+
+    def flush_tracker(self) -> None:
+        """Reset the steps and delete the temporary local directory."""
+        self._reset()
+        shutil.rmtree(self.temp_dir)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/trubrics_callback.py

@@ -0,0 +1,125 @@
+import os
+from typing import Any, Dict, List, Optional
+from uuid import UUID
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.messages import (
+    AIMessage,
+    BaseMessage,
+    ChatMessage,
+    FunctionMessage,
+    HumanMessage,
+    SystemMessage,
+)
+from langchain_core.outputs import LLMResult
+
+
+def _convert_message_to_dict(message: BaseMessage) -> dict:
+    message_dict: Dict[str, Any]
+    if isinstance(message, ChatMessage):
+        message_dict = {"role": message.role, "content": message.content}
+    elif isinstance(message, HumanMessage):
+        message_dict = {"role": "user", "content": message.content}
+    elif isinstance(message, AIMessage):
+        message_dict = {"role": "assistant", "content": message.content}
+        if "function_call" in message.additional_kwargs:
+            message_dict["function_call"] = message.additional_kwargs["function_call"]
+            # If function call only, content is None not empty string
+            if message_dict["content"] == "":
+                message_dict["content"] = None
+    elif isinstance(message, SystemMessage):
+        message_dict = {"role": "system", "content": message.content}
+    elif isinstance(message, FunctionMessage):
+        message_dict = {
+            "role": "function",
+            "content": message.content,
+            "name": message.name,
+        }
+    else:
+        raise TypeError(f"Got unknown type {message}")
+    if "name" in message.additional_kwargs:
+        message_dict["name"] = message.additional_kwargs["name"]
+    return message_dict
+
+
+class TrubricsCallbackHandler(BaseCallbackHandler):
+    """
+    Callback handler for Trubrics.
+
+    Args:
+        project: a trubrics project, default project is "default"
+        email: a trubrics account email, can equally be set in env variables
+        password: a trubrics account password, can equally be set in env variables
+        **kwargs: all other kwargs are parsed and set to trubrics prompt variables,
+            or added to the `metadata` dict
+    """
+
+    def __init__(
+        self,
+        project: str = "default",
+        email: Optional[str] = None,
+        password: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        super().__init__()
+        try:
+            from trubrics import Trubrics
+        except ImportError:
+            raise ImportError(
+                "The TrubricsCallbackHandler requires installation of "
+                "the trubrics package. "
+                "Please install it with `pip install trubrics`."
+            )
+
+        self.trubrics = Trubrics(
+            project=project,
+            email=email or os.environ["TRUBRICS_EMAIL"],
+            password=password or os.environ["TRUBRICS_PASSWORD"],
+        )
+        self.config_model: dict = {}
+        self.prompt: Optional[str] = None
+        self.messages: Optional[list] = None
+        self.trubrics_kwargs: Optional[dict] = kwargs if kwargs else None
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        self.prompt = prompts[0]
+
+    def on_chat_model_start(
+        self,
+        serialized: Dict[str, Any],
+        messages: List[List[BaseMessage]],
+        **kwargs: Any,
+    ) -> None:
+        self.messages = [_convert_message_to_dict(message) for message in messages[0]]
+        self.prompt = self.messages[-1]["content"]
+
+    def on_llm_end(self, response: LLMResult, run_id: UUID, **kwargs: Any) -> None:
+        tags = ["langchain"]
+        user_id = None
+        session_id = None
+        metadata: dict = {"langchain_run_id": run_id}
+        if self.messages:
+            metadata["messages"] = self.messages
+        if self.trubrics_kwargs:
+            if self.trubrics_kwargs.get("tags"):
+                tags.append(*self.trubrics_kwargs.pop("tags"))
+            user_id = self.trubrics_kwargs.pop("user_id", None)
+            session_id = self.trubrics_kwargs.pop("session_id", None)
+            metadata.update(self.trubrics_kwargs)
+
+        for generation in response.generations:
+            self.trubrics.log_prompt(
+                config_model={
+                    "model": response.llm_output.get("model_name")
+                    if response.llm_output
+                    else "NA"
+                },
+                prompt=self.prompt,
+                generation=generation[0].text,
+                user_id=user_id,
+                session_id=session_id,
+                tags=tags,
+                metadata=metadata,
+            )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/upstash_ratelimit_callback.py

@@ -0,0 +1,206 @@
+"""Ratelimiting Handler to limit requests or tokens"""
+
+import logging
+from typing import Any, Dict, List, Literal, Optional
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+
+logger = logging.getLogger(__name__)
+try:
+    from upstash_ratelimit import Ratelimit
+except ImportError:
+    Ratelimit = None
+
+
+class UpstashRatelimitError(Exception):
+    """
+    Upstash Ratelimit Error
+
+    Raised when the rate limit is reached in `UpstashRatelimitHandler`
+    """
+
+    def __init__(
+        self,
+        message: str,
+        type: Literal["token", "request"],
+        limit: Optional[int] = None,
+        reset: Optional[float] = None,
+    ):
+        """
+        Args:
+            message (str): error message
+            type (str): The kind of the limit which was reached. One of
+                "token" or "request"
+            limit (Optional[int]): The limit which was reached. Passed when type
+                is request
+            reset (Optional[int]): unix timestamp in milliseconds when the limits
+                are reset. Passed when type is request
+        """
+        # Call the base class constructor with the parameters it needs
+        super().__init__(message)
+        self.type = type
+        self.limit = limit
+        self.reset = reset
+
+
+class UpstashRatelimitHandler(BaseCallbackHandler):
+    """
+    Callback to handle rate limiting based on the number of requests
+    or the number of tokens in the input.
+
+    It uses Upstash Ratelimit to track the ratelimit which utilizes
+    Upstash Redis to track the state.
+
+    Should not be passed to the chain when initialising the chain.
+    This is because the handler has a state which should be fresh
+    every time invoke is called. Instead, initialise and pass a handler
+    every time you invoke.
+    """
+
+    raise_error: bool = True
+    _checked: bool = False
+
+    def __init__(
+        self,
+        identifier: str,
+        *,
+        token_ratelimit: Optional[Ratelimit] = None,
+        request_ratelimit: Optional[Ratelimit] = None,
+        include_output_tokens: bool = False,
+    ):
+        """
+        Creates UpstashRatelimitHandler. Must be passed an identifier to
+        ratelimit like a user id or an ip address.
+
+        Additionally, it must be passed at least one of token_ratelimit
+        or request_ratelimit parameters.
+
+        Args:
+            identifier Union[int, str]: the identifier
+            token_ratelimit Optional[Ratelimit]: Ratelimit to limit the
+                number of tokens. Only works with OpenAI models since only
+                these models provide the number of tokens as information
+                in their output.
+            request_ratelimit Optional[Ratelimit]: Ratelimit to limit the
+                number of requests
+            include_output_tokens bool: Whether to count output tokens when
+                rate limiting based on number of tokens. Only used when
+                `token_ratelimit` is passed. False by default.
+
+        Example:
+            .. code-block:: python
+
+                from upstash_redis import Redis
+                from upstash_ratelimit import Ratelimit, FixedWindow
+
+                redis = Redis.from_env()
+                ratelimit = Ratelimit(
+                    redis=redis,
+                    # fixed window to allow 10 requests every 10 seconds:
+                    limiter=FixedWindow(max_requests=10, window=10),
+                )
+
+                user_id = "foo"
+                handler = UpstashRatelimitHandler(
+                    identifier=user_id,
+                    request_ratelimit=ratelimit
+                )
+
+                # Initialize a simple runnable to test
+                chain = RunnableLambda(str)
+
+                # pass handler as callback:
+                output = chain.invoke(
+                    "input",
+                    config={
+                        "callbacks": [handler]
+                    }
+                )
+
+        """
+        if not any([token_ratelimit, request_ratelimit]):
+            raise ValueError(
+                "You must pass at least one of input_token_ratelimit or"
+                " request_ratelimit parameters for handler to work."
+            )
+
+        self.identifier = identifier
+        self.token_ratelimit = token_ratelimit
+        self.request_ratelimit = request_ratelimit
+        self.include_output_tokens = include_output_tokens
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> Any:
+        """
+        Run when chain starts running.
+
+        on_chain_start runs multiple times during a chain execution. To make
+        sure that it's only called once, we keep a bool state `_checked`. If
+        not `self._checked`, we call limit with `request_ratelimit` and raise
+        `UpstashRatelimitError` if the identifier is rate limited.
+        """
+        if self.request_ratelimit and not self._checked:
+            response = self.request_ratelimit.limit(self.identifier)
+            if not response.allowed:
+                raise UpstashRatelimitError(
+                    "Request limit reached!", "request", response.limit, response.reset
+                )
+            self._checked = True
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """
+        Run when LLM starts running
+        """
+        if self.token_ratelimit:
+            remaining = self.token_ratelimit.get_remaining(self.identifier)
+            if remaining <= 0:
+                raise UpstashRatelimitError("Token limit reached!", "token")
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """
+        Run when LLM ends running
+
+        If the `include_output_tokens` is set to True, number of tokens
+        in LLM completion are counted for rate limiting
+        """
+        if self.token_ratelimit:
+            try:
+                llm_output = response.llm_output or {}
+                token_usage = llm_output["token_usage"]
+                token_count = (
+                    token_usage["total_tokens"]
+                    if self.include_output_tokens
+                    else token_usage["prompt_tokens"]
+                )
+            except KeyError:
+                raise ValueError(
+                    "LLM response doesn't include"
+                    " `token_usage: {total_tokens: int, prompt_tokens: int}`"
+                    "  field. To use UpstashRatelimitHandler with token_ratelimit,"
+                    " either use a model which returns token_usage (like "
+                    " OpenAI models) or rate limit only with request_ratelimit."
+                )
+
+            # call limit to add the completion tokens to rate limit
+            # but don't raise exception since we already generated
+            # the tokens and would rather continue execution.
+            self.token_ratelimit.limit(self.identifier, rate=token_count)
+
+    def reset(self, identifier: Optional[str] = None) -> "UpstashRatelimitHandler":
+        """
+        Creates a new UpstashRatelimitHandler object with the same
+        ratelimit configurations but with a new identifier if it's
+        provided.
+
+        Also resets the state of the handler.
+        """
+        return UpstashRatelimitHandler(
+            identifier=identifier or self.identifier,
+            token_ratelimit=self.token_ratelimit,
+            request_ratelimit=self.request_ratelimit,
+            include_output_tokens=self.include_output_tokens,
+        )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/uptrain_callback.py

@@ -0,0 +1,384 @@
+"""
+UpTrain Callback Handler
+
+UpTrain is an open-source platform to evaluate and improve LLM applications. It provides
+grades for 20+ preconfigured checks (covering language, code, embedding use cases),
+performs root cause analyses on instances of failure cases and provides guidance for
+resolving them.
+
+This module contains a callback handler for integrating UpTrain seamlessly into your
+pipeline and facilitating diverse evaluations. The callback handler automates various
+evaluations to assess the performance and effectiveness of the components within the
+pipeline.
+
+The evaluations conducted include:
+
+1. RAG:
+   - Context Relevance: Determines the relevance of the context extracted from the query
+   to the response.
+   - Factual Accuracy: Assesses if the Language Model (LLM) is providing accurate
+   information or hallucinating.
+   - Response Completeness: Checks if the response contains all the information
+   requested by the query.
+
+2. Multi Query Generation:
+   MultiQueryRetriever generates multiple variants of a question with similar meanings
+   to the original question. This evaluation includes previous assessments and adds:
+   - Multi Query Accuracy: Ensures that the multi-queries generated convey the same
+   meaning as the original query.
+
+3. Context Compression and Reranking:
+   Re-ranking involves reordering nodes based on relevance to the query and selecting
+   top n nodes.
+   Due to the potential reduction in the number of nodes after re-ranking, the following
+   evaluations
+   are performed in addition to the RAG evaluations:
+   - Context Reranking: Determines if the order of re-ranked nodes is more relevant to
+   the query than the original order.
+   - Context Conciseness: Examines whether the reduced number of nodes still provides
+   all the required information.
+
+These evaluations collectively ensure the robustness and effectiveness of the RAG query
+engine, MultiQueryRetriever, and the re-ranking process within the pipeline.
+
+Useful links:
+Github: https://github.com/uptrain-ai/uptrain
+Website: https://uptrain.ai/
+Docs: https://docs.uptrain.ai/getting-started/introduction
+
+"""
+
+import logging
+import sys
+from collections import defaultdict
+from typing import (
+    Any,
+    DefaultDict,
+    Dict,
+    List,
+    Optional,
+    Sequence,
+    Set,
+)
+from uuid import UUID
+
+from langchain_core.callbacks.base import BaseCallbackHandler
+from langchain_core.documents import Document
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+logger = logging.getLogger(__name__)
+handler = logging.StreamHandler(sys.stdout)
+formatter = logging.Formatter("%(message)s")
+handler.setFormatter(formatter)
+logger.addHandler(handler)
+
+
+def import_uptrain() -> Any:
+    """Import the `uptrain` package."""
+    return guard_import("uptrain")
+
+
+class UpTrainDataSchema:
+    """The UpTrain data schema for tracking evaluation results.
+
+    Args:
+        project_name (str): The project name to be shown in UpTrain dashboard.
+
+    Attributes:
+        project_name (str): The project name to be shown in UpTrain dashboard.
+        uptrain_results (DefaultDict[str, Any]): Dictionary to store evaluation results.
+        eval_types (Set[str]): Set to store the types of evaluations.
+        query (str): Query for the RAG evaluation.
+        context (str): Context for the RAG evaluation.
+        response (str): Response for the RAG evaluation.
+        old_context (List[str]): Old context nodes for Context Conciseness evaluation.
+        new_context (List[str]): New context nodes for Context Conciseness evaluation.
+        context_conciseness_run_id (str): Run ID for Context Conciseness evaluation.
+        multi_queries (List[str]): List of multi queries for Multi Query evaluation.
+        multi_query_run_id (str): Run ID for Multi Query evaluation.
+        multi_query_daugher_run_id (str): Run ID for Multi Query daughter evaluation.
+
+    """
+
+    def __init__(self, project_name: str) -> None:
+        """Initialize the UpTrain data schema."""
+        # For tracking project name and results
+        self.project_name: str = project_name
+        self.uptrain_results: DefaultDict[str, Any] = defaultdict(list)
+
+        # For tracking event types
+        self.eval_types: Set[str] = set()
+
+        ## RAG
+        self.query: str = ""
+        self.context: str = ""
+        self.response: str = ""
+
+        ## CONTEXT CONCISENESS
+        self.old_context: List[str] = []
+        self.new_context: List[str] = []
+        self.context_conciseness_run_id: UUID = UUID(int=0)
+
+        # MULTI QUERY
+        self.multi_queries: List[str] = []
+        self.multi_query_run_id: UUID = UUID(int=0)
+        self.multi_query_daugher_run_id: UUID = UUID(int=0)
+
+
+class UpTrainCallbackHandler(BaseCallbackHandler):
+    """Callback Handler that logs evaluation results to uptrain and the console.
+
+    Args:
+        project_name (str): The project name to be shown in UpTrain dashboard.
+        key_type (str): Type of key to use. Must be 'uptrain' or 'openai'.
+        api_key (str): API key for the UpTrain or OpenAI API.
+        (This key is required to perform evaluations using GPT.)
+
+    Raises:
+        ValueError: If the key type is invalid.
+        ImportError: If the `uptrain` package is not installed.
+
+    """
+
+    def __init__(
+        self,
+        *,
+        project_name: str = "langchain",
+        key_type: str = "openai",
+        api_key: str = "sk-****************",  # The API key to use for evaluation
+        model: str = "gpt-3.5-turbo",  # The model to use for evaluation
+        log_results: bool = True,
+    ) -> None:
+        """Initializes the `UpTrainCallbackHandler`."""
+        super().__init__()
+
+        uptrain = import_uptrain()
+
+        self.log_results = log_results
+
+        # Set uptrain variables
+        self.schema = UpTrainDataSchema(project_name=project_name)
+        self.first_score_printed_flag = False
+
+        if key_type == "uptrain":
+            settings = uptrain.Settings(uptrain_access_token=api_key, model=model)
+            self.uptrain_client = uptrain.APIClient(settings=settings)
+        elif key_type == "openai":
+            settings = uptrain.Settings(
+                openai_api_key=api_key, evaluate_locally=True, model=model
+            )
+            self.uptrain_client = uptrain.EvalLLM(settings=settings)
+        else:
+            raise ValueError("Invalid key type: Must be 'uptrain' or 'openai'")
+
+    def uptrain_evaluate(
+        self,
+        evaluation_name: str,
+        data: List[Dict[str, Any]],
+        checks: List[str],
+    ) -> None:
+        """Run an evaluation on the UpTrain server using UpTrain client."""
+        if self.uptrain_client.__class__.__name__ == "APIClient":
+            uptrain_result = self.uptrain_client.log_and_evaluate(
+                project_name=self.schema.project_name,
+                evaluation_name=evaluation_name,
+                data=data,
+                checks=checks,
+            )
+        else:
+            uptrain_result = self.uptrain_client.evaluate(
+                project_name=self.schema.project_name,
+                evaluation_name=evaluation_name,
+                data=data,
+                checks=checks,
+            )
+        self.schema.uptrain_results[self.schema.project_name].append(uptrain_result)
+
+        score_name_map = {
+            "score_context_relevance": "Context Relevance Score",
+            "score_factual_accuracy": "Factual Accuracy Score",
+            "score_response_completeness": "Response Completeness Score",
+            "score_sub_query_completeness": "Sub Query Completeness Score",
+            "score_context_reranking": "Context Reranking Score",
+            "score_context_conciseness": "Context Conciseness Score",
+            "score_multi_query_accuracy": "Multi Query Accuracy Score",
+        }
+
+        if self.log_results:
+            # Set logger level to INFO to print the evaluation results
+            logger.setLevel(logging.INFO)
+
+        for row in uptrain_result:
+            columns = list(row.keys())
+            for column in columns:
+                if column == "question":
+                    logger.info(f"\nQuestion: {row[column]}")
+                    self.first_score_printed_flag = False
+                elif column == "response":
+                    logger.info(f"Response: {row[column]}")
+                    self.first_score_printed_flag = False
+                elif column == "variants":
+                    logger.info("Multi Queries:")
+                    for variant in row[column]:
+                        logger.info(f"  - {variant}")
+                    self.first_score_printed_flag = False
+                elif column.startswith("score"):
+                    if not self.first_score_printed_flag:
+                        logger.info("")
+                        self.first_score_printed_flag = True
+                    if column in score_name_map:
+                        logger.info(f"{score_name_map[column]}: {row[column]}")
+                    else:
+                        logger.info(f"{column}: {row[column]}")
+
+        if self.log_results:
+            # Set logger level back to WARNING
+            # (We are doing this to avoid printing the logs from HTTP requests)
+            logger.setLevel(logging.WARNING)
+
+    def on_llm_end(
+        self,
+        response: LLMResult,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Log records to uptrain when an LLM ends."""
+        uptrain = import_uptrain()
+        self.schema.response = response.generations[0][0].text
+        if (
+            "qa_rag" in self.schema.eval_types
+            and parent_run_id != self.schema.multi_query_daugher_run_id
+        ):
+            data = [
+                {
+                    "question": self.schema.query,
+                    "context": self.schema.context,
+                    "response": self.schema.response,
+                }
+            ]
+
+            self.uptrain_evaluate(
+                evaluation_name="rag",
+                data=data,
+                checks=[
+                    uptrain.Evals.CONTEXT_RELEVANCE,
+                    uptrain.Evals.FACTUAL_ACCURACY,
+                    uptrain.Evals.RESPONSE_COMPLETENESS,
+                ],
+            )
+
+    def on_chain_start(
+        self,
+        serialized: Dict[str, Any],
+        inputs: Dict[str, Any],
+        *,
+        run_id: UUID,
+        tags: Optional[List[str]] = None,
+        parent_run_id: Optional[UUID] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        run_type: Optional[str] = None,
+        name: Optional[str] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Do nothing when chain starts"""
+        if parent_run_id == self.schema.multi_query_run_id:
+            self.schema.multi_query_daugher_run_id = run_id
+        if isinstance(inputs, dict) and set(inputs.keys()) == {"context", "question"}:
+            self.schema.eval_types.add("qa_rag")
+
+            context = ""
+            if isinstance(inputs["context"], Document):
+                context = inputs["context"].page_content
+            elif isinstance(inputs["context"], list):
+                for doc in inputs["context"]:
+                    context += doc.page_content + "\n"
+            elif isinstance(inputs["context"], str):
+                context = inputs["context"]
+            self.schema.context = context
+            self.schema.query = inputs["question"]
+        pass
+
+    def on_retriever_start(
+        self,
+        serialized: Dict[str, Any],
+        query: str,
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        if "contextual_compression" in serialized["id"]:
+            self.schema.eval_types.add("contextual_compression")
+            self.schema.query = query
+            self.schema.context_conciseness_run_id = run_id
+
+        if "multi_query" in serialized["id"]:
+            self.schema.eval_types.add("multi_query")
+            self.schema.multi_query_run_id = run_id
+            self.schema.query = query
+        elif "multi_query" in self.schema.eval_types:
+            self.schema.multi_queries.append(query)
+
+    def on_retriever_end(
+        self,
+        documents: Sequence[Document],
+        *,
+        run_id: UUID,
+        parent_run_id: Optional[UUID] = None,
+        **kwargs: Any,
+    ) -> Any:
+        """Run when Retriever ends running."""
+        uptrain = import_uptrain()
+        if run_id == self.schema.multi_query_run_id:
+            data = [
+                {
+                    "question": self.schema.query,
+                    "variants": self.schema.multi_queries,
+                }
+            ]
+
+            self.uptrain_evaluate(
+                evaluation_name="multi_query",
+                data=data,
+                checks=[uptrain.Evals.MULTI_QUERY_ACCURACY],
+            )
+        if "contextual_compression" in self.schema.eval_types:
+            if parent_run_id == self.schema.context_conciseness_run_id:
+                for doc in documents:
+                    self.schema.old_context.append(doc.page_content)
+            elif run_id == self.schema.context_conciseness_run_id:
+                for doc in documents:
+                    self.schema.new_context.append(doc.page_content)
+                context = "\n".join(
+                    [
+                        f"{index}. {string}"
+                        for index, string in enumerate(self.schema.old_context, start=1)
+                    ]
+                )
+                reranked_context = "\n".join(
+                    [
+                        f"{index}. {string}"
+                        for index, string in enumerate(self.schema.new_context, start=1)
+                    ]
+                )
+                data = [
+                    {
+                        "question": self.schema.query,
+                        "context": context,
+                        "concise_context": reranked_context,
+                        "reranked_context": reranked_context,
+                    }
+                ]
+                self.uptrain_evaluate(
+                    evaluation_name="context_reranking",
+                    data=data,
+                    checks=[
+                        uptrain.Evals.CONTEXT_CONCISENESS,
+                        uptrain.Evals.CONTEXT_RERANKING,
+                    ],
+                )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/utils.py

@@ -0,0 +1,239 @@
+import hashlib
+from pathlib import Path
+from typing import Any, Dict, Iterable, Tuple, Union
+
+from langchain_core.utils import guard_import
+
+
+def import_spacy() -> Any:
+    """Import the spacy python package and raise an error if it is not installed."""
+    return guard_import("spacy")
+
+
+def import_pandas() -> Any:
+    """Import the pandas python package and raise an error if it is not installed."""
+    return guard_import("pandas")
+
+
+def import_textstat() -> Any:
+    """Import the textstat python package and raise an error if it is not installed."""
+    return guard_import("textstat")
+
+
+def _flatten_dict(
+    nested_dict: Dict[str, Any], parent_key: str = "", sep: str = "_"
+) -> Iterable[Tuple[str, Any]]:
+    """
+    Generator that yields flattened items from a nested dictionary for a flat dict.
+
+    Parameters:
+        nested_dict (dict): The nested dictionary to flatten.
+        parent_key (str): The prefix to prepend to the keys of the flattened dict.
+        sep (str): The separator to use between the parent key and the key of the
+            flattened dictionary.
+
+    Yields:
+        (str, any): A key-value pair from the flattened dictionary.
+    """
+    for key, value in nested_dict.items():
+        new_key = parent_key + sep + key if parent_key else key
+        if isinstance(value, dict):
+            yield from _flatten_dict(value, new_key, sep)
+        else:
+            yield new_key, value
+
+
+def flatten_dict(
+    nested_dict: Dict[str, Any], parent_key: str = "", sep: str = "_"
+) -> Dict[str, Any]:
+    """Flatten a nested dictionary into a flat dictionary.
+
+    Parameters:
+        nested_dict (dict): The nested dictionary to flatten.
+        parent_key (str): The prefix to prepend to the keys of the flattened dict.
+        sep (str): The separator to use between the parent key and the key of the
+            flattened dictionary.
+
+    Returns:
+        (dict): A flat dictionary.
+
+    """
+    flat_dict = {k: v for k, v in _flatten_dict(nested_dict, parent_key, sep)}
+    return flat_dict
+
+
+def hash_string(s: str) -> str:
+    """Hash a string using sha1.
+
+    Parameters:
+        s (str): The string to hash.
+
+    Returns:
+        (str): The hashed string.
+    """
+    return hashlib.sha1(s.encode("utf-8")).hexdigest()
+
+
+def load_json(json_path: Union[str, Path]) -> str:
+    """Load json file to a string.
+
+    Parameters:
+        json_path (str): The path to the json file.
+
+    Returns:
+        (str): The string representation of the json file.
+    """
+    with open(json_path, "r") as f:
+        data = f.read()
+    return data
+
+
+class BaseMetadataCallbackHandler:
+    """Handle the metadata and associated function states for callbacks.
+
+    Attributes:
+        step (int): The current step.
+        starts (int): The number of times the start method has been called.
+        ends (int): The number of times the end method has been called.
+        errors (int): The number of times the error method has been called.
+        text_ctr (int): The number of times the text method has been called.
+        ignore_llm_ (bool): Whether to ignore llm callbacks.
+        ignore_chain_ (bool): Whether to ignore chain callbacks.
+        ignore_agent_ (bool): Whether to ignore agent callbacks.
+        ignore_retriever_ (bool): Whether to ignore retriever callbacks.
+        always_verbose_ (bool): Whether to always be verbose.
+        chain_starts (int): The number of times the chain start method has been called.
+        chain_ends (int): The number of times the chain end method has been called.
+        llm_starts (int): The number of times the llm start method has been called.
+        llm_ends (int): The number of times the llm end method has been called.
+        llm_streams (int): The number of times the text method has been called.
+        tool_starts (int): The number of times the tool start method has been called.
+        tool_ends (int): The number of times the tool end method has been called.
+        agent_ends (int): The number of times the agent end method has been called.
+        on_llm_start_records (list): A list of records of the on_llm_start method.
+        on_llm_token_records (list): A list of records of the on_llm_token method.
+        on_llm_end_records (list): A list of records of the on_llm_end method.
+        on_chain_start_records (list): A list of records of the on_chain_start method.
+        on_chain_end_records (list): A list of records of the on_chain_end method.
+        on_tool_start_records (list): A list of records of the on_tool_start method.
+        on_tool_end_records (list): A list of records of the on_tool_end method.
+        on_agent_finish_records (list): A list of records of the on_agent_end method.
+    """
+
+    def __init__(self) -> None:
+        self.step = 0
+
+        self.starts = 0
+        self.ends = 0
+        self.errors = 0
+        self.text_ctr = 0
+
+        self.ignore_llm_ = False
+        self.ignore_chain_ = False
+        self.ignore_agent_ = False
+        self.ignore_retriever_ = False
+        self.always_verbose_ = False
+
+        self.chain_starts = 0
+        self.chain_ends = 0
+
+        self.llm_starts = 0
+        self.llm_ends = 0
+        self.llm_streams = 0
+
+        self.tool_starts = 0
+        self.tool_ends = 0
+
+        self.agent_ends = 0
+
+        self.on_llm_start_records: list = []
+        self.on_llm_token_records: list = []
+        self.on_llm_end_records: list = []
+
+        self.on_chain_start_records: list = []
+        self.on_chain_end_records: list = []
+
+        self.on_tool_start_records: list = []
+        self.on_tool_end_records: list = []
+
+        self.on_text_records: list = []
+        self.on_agent_finish_records: list = []
+        self.on_agent_action_records: list = []
+
+    @property
+    def always_verbose(self) -> bool:
+        """Whether to call verbose callbacks even if verbose is False."""
+        return self.always_verbose_
+
+    @property
+    def ignore_llm(self) -> bool:
+        """Whether to ignore LLM callbacks."""
+        return self.ignore_llm_
+
+    @property
+    def ignore_chain(self) -> bool:
+        """Whether to ignore chain callbacks."""
+        return self.ignore_chain_
+
+    @property
+    def ignore_agent(self) -> bool:
+        """Whether to ignore agent callbacks."""
+        return self.ignore_agent_
+
+    def get_custom_callback_meta(self) -> Dict[str, Any]:
+        return {
+            "step": self.step,
+            "starts": self.starts,
+            "ends": self.ends,
+            "errors": self.errors,
+            "text_ctr": self.text_ctr,
+            "chain_starts": self.chain_starts,
+            "chain_ends": self.chain_ends,
+            "llm_starts": self.llm_starts,
+            "llm_ends": self.llm_ends,
+            "llm_streams": self.llm_streams,
+            "tool_starts": self.tool_starts,
+            "tool_ends": self.tool_ends,
+            "agent_ends": self.agent_ends,
+        }
+
+    def reset_callback_meta(self) -> None:
+        """Reset the callback metadata."""
+        self.step = 0
+
+        self.starts = 0
+        self.ends = 0
+        self.errors = 0
+        self.text_ctr = 0
+
+        self.ignore_llm_ = False
+        self.ignore_chain_ = False
+        self.ignore_agent_ = False
+        self.always_verbose_ = False
+
+        self.chain_starts = 0
+        self.chain_ends = 0
+
+        self.llm_starts = 0
+        self.llm_ends = 0
+        self.llm_streams = 0
+
+        self.tool_starts = 0
+        self.tool_ends = 0
+
+        self.agent_ends = 0
+
+        self.on_llm_start_records = []
+        self.on_llm_token_records = []
+        self.on_llm_end_records = []
+
+        self.on_chain_start_records = []
+        self.on_chain_end_records = []
+
+        self.on_tool_start_records = []
+        self.on_tool_end_records = []
+
+        self.on_text_records = []
+        self.on_agent_finish_records = []
+        self.on_agent_action_records = []
+        return None

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/wandb_callback.py

@@ -0,0 +1,597 @@
+import json
+import tempfile
+from copy import deepcopy
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Sequence, Union
+
+from langchain_core._api import warn_deprecated
+from langchain_core.agents import AgentAction, AgentFinish
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.outputs import LLMResult
+from langchain_core.utils import guard_import
+
+from langchain_community.callbacks.utils import (
+    BaseMetadataCallbackHandler,
+    flatten_dict,
+    hash_string,
+    import_pandas,
+    import_spacy,
+    import_textstat,
+)
+
+
+def import_wandb() -> Any:
+    """Import the wandb python package and raise an error if it is not installed."""
+    return guard_import("wandb")
+
+
+def load_json_to_dict(json_path: Union[str, Path]) -> dict:
+    """Load json file to a dictionary.
+
+    Parameters:
+        json_path (str): The path to the json file.
+
+    Returns:
+        (dict): The dictionary representation of the json file.
+    """
+    with open(json_path, "r") as f:
+        data = json.load(f)
+    return data
+
+
+def analyze_text(
+    text: str,
+    complexity_metrics: bool = True,
+    visualize: bool = True,
+    nlp: Any = None,
+    output_dir: Optional[Union[str, Path]] = None,
+) -> dict:
+    """Analyze text using textstat and spacy.
+
+    Parameters:
+        text (str): The text to analyze.
+        complexity_metrics (bool): Whether to compute complexity metrics.
+        visualize (bool): Whether to visualize the text.
+        nlp (spacy.lang): The spacy language model to use for visualization.
+        output_dir (str): The directory to save the visualization files to.
+
+    Returns:
+        `dict` containing the complexity metrics and visualization
+            files serialized in a wandb.Html element.
+    """
+    resp = {}
+    textstat = import_textstat()
+    wandb = import_wandb()
+    spacy = import_spacy()
+    if complexity_metrics:
+        text_complexity_metrics = {
+            "flesch_reading_ease": textstat.flesch_reading_ease(text),
+            "flesch_kincaid_grade": textstat.flesch_kincaid_grade(text),
+            "smog_index": textstat.smog_index(text),
+            "coleman_liau_index": textstat.coleman_liau_index(text),
+            "automated_readability_index": textstat.automated_readability_index(text),
+            "dale_chall_readability_score": textstat.dale_chall_readability_score(text),
+            "difficult_words": textstat.difficult_words(text),
+            "linsear_write_formula": textstat.linsear_write_formula(text),
+            "gunning_fog": textstat.gunning_fog(text),
+            "text_standard": textstat.text_standard(text),
+            "fernandez_huerta": textstat.fernandez_huerta(text),
+            "szigriszt_pazos": textstat.szigriszt_pazos(text),
+            "gutierrez_polini": textstat.gutierrez_polini(text),
+            "crawford": textstat.crawford(text),
+            "gulpease_index": textstat.gulpease_index(text),
+            "osman": textstat.osman(text),
+        }
+        resp.update(text_complexity_metrics)
+
+    if visualize and nlp and output_dir is not None:
+        doc = nlp(text)
+
+        dep_out = spacy.displacy.render(doc, style="dep", jupyter=False, page=True)
+        dep_output_path = Path(output_dir, hash_string(f"dep-{text}") + ".html")
+        dep_output_path.open("w", encoding="utf-8").write(dep_out)
+
+        ent_out = spacy.displacy.render(doc, style="ent", jupyter=False, page=True)
+        ent_output_path = Path(output_dir, hash_string(f"ent-{text}") + ".html")
+        ent_output_path.open("w", encoding="utf-8").write(ent_out)
+
+        text_visualizations = {
+            "dependency_tree": wandb.Html(str(dep_output_path)),
+            "entities": wandb.Html(str(ent_output_path)),
+        }
+        resp.update(text_visualizations)
+
+    return resp
+
+
+def construct_html_from_prompt_and_generation(prompt: str, generation: str) -> Any:
+    """Construct an html element from a prompt and a generation.
+
+    Parameters:
+        prompt (str): The prompt.
+        generation (str): The generation.
+
+    Returns:
+        (wandb.Html): The html element."""
+    wandb = import_wandb()
+    formatted_prompt = prompt.replace("\n", "<br>")
+    formatted_generation = generation.replace("\n", "<br>")
+
+    return wandb.Html(
+        f"""
+    <p style="color:black;">{formatted_prompt}:</p>
+    <blockquote>
+      <p style="color:green;">
+        {formatted_generation}
+      </p>
+    </blockquote>
+    """,
+        inject=False,
+    )
+
+
+class WandbCallbackHandler(BaseMetadataCallbackHandler, BaseCallbackHandler):
+    """Callback Handler that logs to Weights and Biases.
+
+    Parameters:
+        job_type (str): The type of job.
+        project (str): The project to log to.
+        entity (str): The entity to log to.
+        tags (list): The tags to log.
+        group (str): The group to log to.
+        name (str): The name of the run.
+        notes (str): The notes to log.
+        visualize (bool): Whether to visualize the run.
+        complexity_metrics (bool): Whether to log complexity metrics.
+        stream_logs (bool): Whether to stream callback actions to W&B
+
+    This handler will utilize the associated callback method called and formats
+    the input of each callback function with metadata regarding the state of LLM run,
+    and adds the response to the list of records for both the {method}_records and
+    action. It then logs the response using the run.log() method to Weights and Biases.
+    """
+
+    def __init__(
+        self,
+        job_type: Optional[str] = None,
+        project: Optional[str] = "langchain_callback_demo",
+        entity: Optional[str] = None,
+        tags: Optional[Sequence] = None,
+        group: Optional[str] = None,
+        name: Optional[str] = None,
+        notes: Optional[str] = None,
+        visualize: bool = False,
+        complexity_metrics: bool = False,
+        stream_logs: bool = False,
+    ) -> None:
+        """Initialize callback handler."""
+
+        wandb = import_wandb()
+        import_pandas()
+        import_textstat()
+        spacy = import_spacy()
+        super().__init__()
+
+        self.job_type = job_type
+        self.project = project
+        self.entity = entity
+        self.tags = tags
+        self.group = group
+        self.name = name
+        self.notes = notes
+        self.visualize = visualize
+        self.complexity_metrics = complexity_metrics
+        self.stream_logs = stream_logs
+
+        self.temp_dir = tempfile.TemporaryDirectory()
+        self.run = wandb.init(
+            job_type=self.job_type,
+            project=self.project,
+            entity=self.entity,
+            tags=self.tags,
+            group=self.group,
+            name=self.name,
+            notes=self.notes,
+        )
+        warning = (
+            "DEPRECATION: The `WandbCallbackHandler` will soon be deprecated in favor "
+            "of the `WandbTracer`. Please update your code to use the `WandbTracer` "
+            "instead."
+        )
+        wandb.termwarn(
+            warning,
+            repeat=False,
+        )
+        self.callback_columns: list = []
+        self.action_records: list = []
+        self.complexity_metrics = complexity_metrics
+        self.visualize = visualize
+        self.nlp = spacy.load("en_core_web_sm")
+        warn_deprecated(
+            "0.3.8",
+            pending=False,
+            message=(
+                "Please use the WeaveTracer instead of the WandbCallbackHandler. "
+                "The WeaveTracer is a more flexible and powerful tool for logging "
+                "and tracing your LangChain callables."
+                "Find more information at https://weave-docs.wandb.ai/guides/integrations/langchain"
+            ),
+            alternative=(
+                "Please instantiate the WeaveTracer from "
+                "weave.integrations.langchain import WeaveTracer ."
+                "For autologging simply use weave.init() and log all traces "
+                "from your LangChain callables."
+            ),
+        )
+
+    def _init_resp(self) -> Dict:
+        return {k: None for k in self.callback_columns}
+
+    def on_llm_start(
+        self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Run when LLM starts."""
+        self.step += 1
+        self.llm_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        for prompt in prompts:
+            prompt_resp = deepcopy(resp)
+            prompt_resp["prompts"] = prompt
+            self.on_llm_start_records.append(prompt_resp)
+            self.action_records.append(prompt_resp)
+            if self.stream_logs:
+                self.run.log(prompt_resp)
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Run when LLM generates a new token."""
+        self.step += 1
+        self.llm_streams += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_new_token", "token": token})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_llm_token_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
+        """Run when LLM ends running."""
+        self.step += 1
+        self.llm_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_llm_end"})
+        resp.update(flatten_dict(response.llm_output or {}))
+        resp.update(self.get_custom_callback_meta())
+
+        for generations in response.generations:
+            for generation in generations:
+                generation_resp = deepcopy(resp)
+                generation_resp.update(flatten_dict(generation.dict()))
+                generation_resp.update(
+                    analyze_text(
+                        generation.text,
+                        complexity_metrics=self.complexity_metrics,
+                        visualize=self.visualize,
+                        nlp=self.nlp,
+                        output_dir=self.temp_dir.name,
+                    )
+                )
+                self.on_llm_end_records.append(generation_resp)
+                self.action_records.append(generation_resp)
+                if self.stream_logs:
+                    self.run.log(generation_resp)
+
+    def on_llm_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when LLM errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_chain_start(
+        self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        """Run when chain starts running."""
+        self.step += 1
+        self.chain_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_chain_start"})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        chain_input = inputs["input"]
+
+        if isinstance(chain_input, str):
+            input_resp = deepcopy(resp)
+            input_resp["input"] = chain_input
+            self.on_chain_start_records.append(input_resp)
+            self.action_records.append(input_resp)
+            if self.stream_logs:
+                self.run.log(input_resp)
+        elif isinstance(chain_input, list):
+            for inp in chain_input:
+                input_resp = deepcopy(resp)
+                input_resp.update(inp)
+                self.on_chain_start_records.append(input_resp)
+                self.action_records.append(input_resp)
+                if self.stream_logs:
+                    self.run.log(input_resp)
+        else:
+            raise ValueError("Unexpected data format provided!")
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Run when chain ends running."""
+        self.step += 1
+        self.chain_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_chain_end", "outputs": outputs["output"]})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_chain_end_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def on_chain_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when chain errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_tool_start(
+        self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Run when tool starts running."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_tool_start", "input_str": input_str})
+        resp.update(flatten_dict(serialized))
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_tool_start_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def on_tool_end(self, output: Any, **kwargs: Any) -> None:
+        """Run when tool ends running."""
+        output = str(output)
+        self.step += 1
+        self.tool_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_tool_end", "output": output})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_tool_end_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def on_tool_error(self, error: BaseException, **kwargs: Any) -> None:
+        """Run when tool errors."""
+        self.step += 1
+        self.errors += 1
+
+    def on_text(self, text: str, **kwargs: Any) -> None:
+        """
+        Run when agent is ending.
+        """
+        self.step += 1
+        self.text_ctr += 1
+
+        resp = self._init_resp()
+        resp.update({"action": "on_text", "text": text})
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_text_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def on_agent_finish(self, finish: AgentFinish, **kwargs: Any) -> None:
+        """Run when agent ends running."""
+        self.step += 1
+        self.agent_ends += 1
+        self.ends += 1
+
+        resp = self._init_resp()
+        resp.update(
+            {
+                "action": "on_agent_finish",
+                "output": finish.return_values["output"],
+                "log": finish.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+
+        self.on_agent_finish_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def on_agent_action(self, action: AgentAction, **kwargs: Any) -> Any:
+        """Run on agent action."""
+        self.step += 1
+        self.tool_starts += 1
+        self.starts += 1
+
+        resp = self._init_resp()
+        resp.update(
+            {
+                "action": "on_agent_action",
+                "tool": action.tool,
+                "tool_input": action.tool_input,
+                "log": action.log,
+            }
+        )
+        resp.update(self.get_custom_callback_meta())
+        self.on_agent_action_records.append(resp)
+        self.action_records.append(resp)
+        if self.stream_logs:
+            self.run.log(resp)
+
+    def _create_session_analysis_df(self) -> Any:
+        """Create a dataframe with all the information from the session."""
+        pd = import_pandas()
+        on_llm_start_records_df = pd.DataFrame(self.on_llm_start_records)
+        on_llm_end_records_df = pd.DataFrame(self.on_llm_end_records)
+
+        llm_input_prompts_df = (
+            on_llm_start_records_df[["step", "prompts", "name"]]
+            .dropna(axis=1)
+            .rename({"step": "prompt_step"}, axis=1)
+        )
+        complexity_metrics_columns = []
+        visualizations_columns = []
+
+        if self.complexity_metrics:
+            complexity_metrics_columns = [
+                "flesch_reading_ease",
+                "flesch_kincaid_grade",
+                "smog_index",
+                "coleman_liau_index",
+                "automated_readability_index",
+                "dale_chall_readability_score",
+                "difficult_words",
+                "linsear_write_formula",
+                "gunning_fog",
+                "text_standard",
+                "fernandez_huerta",
+                "szigriszt_pazos",
+                "gutierrez_polini",
+                "crawford",
+                "gulpease_index",
+                "osman",
+            ]
+
+        if self.visualize:
+            visualizations_columns = ["dependency_tree", "entities"]
+
+        llm_outputs_df = (
+            on_llm_end_records_df[
+                [
+                    "step",
+                    "text",
+                    "token_usage_total_tokens",
+                    "token_usage_prompt_tokens",
+                    "token_usage_completion_tokens",
+                ]
+                + complexity_metrics_columns
+                + visualizations_columns
+            ]
+            .dropna(axis=1)
+            .rename({"step": "output_step", "text": "output"}, axis=1)
+        )
+        session_analysis_df = pd.concat([llm_input_prompts_df, llm_outputs_df], axis=1)
+        session_analysis_df["chat_html"] = session_analysis_df[
+            ["prompts", "output"]
+        ].apply(
+            lambda row: construct_html_from_prompt_and_generation(
+                row["prompts"], row["output"]
+            ),
+            axis=1,
+        )
+        return session_analysis_df
+
+    def flush_tracker(
+        self,
+        langchain_asset: Any = None,
+        reset: bool = True,
+        finish: bool = False,
+        job_type: Optional[str] = None,
+        project: Optional[str] = None,
+        entity: Optional[str] = None,
+        tags: Optional[Sequence] = None,
+        group: Optional[str] = None,
+        name: Optional[str] = None,
+        notes: Optional[str] = None,
+        visualize: Optional[bool] = None,
+        complexity_metrics: Optional[bool] = None,
+    ) -> None:
+        """Flush the tracker and reset the session.
+
+        Args:
+            langchain_asset: The langchain asset to save.
+            reset: Whether to reset the session.
+            finish: Whether to finish the run.
+            job_type: The job type.
+            project: The project.
+            entity: The entity.
+            tags: The tags.
+            group: The group.
+            name: The name.
+            notes: The notes.
+            visualize: Whether to visualize.
+            complexity_metrics: Whether to compute complexity metrics.
+
+            Returns:
+                None
+        """
+        pd = import_pandas()
+        wandb = import_wandb()
+        action_records_table = wandb.Table(dataframe=pd.DataFrame(self.action_records))
+        session_analysis_table = wandb.Table(
+            dataframe=self._create_session_analysis_df()
+        )
+        self.run.log(
+            {
+                "action_records": action_records_table,
+                "session_analysis": session_analysis_table,
+            }
+        )
+
+        if langchain_asset:
+            langchain_asset_path = Path(self.temp_dir.name, "model.json")
+            model_artifact = wandb.Artifact(name="model", type="model")
+            model_artifact.add(action_records_table, name="action_records")
+            model_artifact.add(session_analysis_table, name="session_analysis")
+            try:
+                langchain_asset.save(langchain_asset_path)
+                model_artifact.add_file(str(langchain_asset_path))
+                model_artifact.metadata = load_json_to_dict(langchain_asset_path)
+            except ValueError:
+                langchain_asset.save_agent(langchain_asset_path)
+                model_artifact.add_file(str(langchain_asset_path))
+                model_artifact.metadata = load_json_to_dict(langchain_asset_path)
+            except NotImplementedError as e:
+                print("Could not save model.")  # noqa: T201
+                print(repr(e))  # noqa: T201
+                pass
+            self.run.log_artifact(model_artifact)
+
+        if finish or reset:
+            self.run.finish()
+            self.temp_dir.cleanup()
+            self.reset_callback_meta()
+        if reset:
+            self.__init__(  # type: ignore[misc]
+                job_type=job_type if job_type else self.job_type,
+                project=project if project else self.project,
+                entity=entity if entity else self.entity,
+                tags=tags if tags else self.tags,
+                group=group if group else self.group,
+                name=name if name else self.name,
+                notes=notes if notes else self.notes,
+                visualize=visualize if visualize else self.visualize,
+                complexity_metrics=(
+                    complexity_metrics
+                    if complexity_metrics
+                    else self.complexity_metrics
+                ),
+            )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/callbacks/whylabs_callback.py

@@ -0,0 +1,187 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Optional
+
+from langchain_core.callbacks import BaseCallbackHandler
+from langchain_core.utils import get_from_env, guard_import
+
+if TYPE_CHECKING:
+    from whylogs.api.logger.logger import Logger
+
+diagnostic_logger = logging.getLogger(__name__)
+
+
+def import_langkit(
+    sentiment: bool = False,
+    toxicity: bool = False,
+    themes: bool = False,
+) -> Any:
+    """Import the langkit python package and raise an error if it is not installed.
+
+    Args:
+        sentiment: Whether to import the langkit.sentiment module. Defaults to False.
+        toxicity: Whether to import the langkit.toxicity module. Defaults to False.
+        themes: Whether to import the langkit.themes module. Defaults to False.
+
+    Returns:
+        The imported langkit module.
+    """
+    langkit = guard_import("langkit")
+    guard_import("langkit.regexes")
+    guard_import("langkit.textstat")
+    if sentiment:
+        guard_import("langkit.sentiment")
+    if toxicity:
+        guard_import("langkit.toxicity")
+    if themes:
+        guard_import("langkit.themes")
+    return langkit
+
+
+class WhyLabsCallbackHandler(BaseCallbackHandler):
+    """
+    Callback Handler for logging to WhyLabs. This callback handler utilizes
+    `langkit` to extract features from the prompts & responses when interacting with
+    an LLM. These features can be used to guardrail, evaluate, and observe interactions
+    over time to detect issues relating to hallucinations, prompt engineering,
+    or output validation. LangKit is an LLM monitoring toolkit developed by WhyLabs.
+
+    Here are some examples of what can be monitored with LangKit:
+    * Text Quality
+      - readability score
+      - complexity and grade scores
+    * Text Relevance
+      - Similarity scores between prompt/responses
+      - Similarity scores against user-defined themes
+      - Topic classification
+    * Security and Privacy
+      - patterns - count of strings matching a user-defined regex pattern group
+      - jailbreaks - similarity scores with respect to known jailbreak attempts
+      - prompt injection - similarity scores with respect to known prompt attacks
+      - refusals - similarity scores with respect to known LLM refusal responses
+    * Sentiment and Toxicity
+      - sentiment analysis
+      - toxicity analysis
+
+    For more information, see https://docs.whylabs.ai/docs/language-model-monitoring
+    or check out the LangKit repo here: https://github.com/whylabs/langkit
+
+    ---
+    Args:
+        api_key (Optional[str]): WhyLabs API key. Optional because the preferred
+            way to specify the API key is with environment variable
+            WHYLABS_API_KEY.
+        org_id (Optional[str]): WhyLabs organization id to write profiles to.
+            Optional because the preferred way to specify the organization id is
+            with environment variable WHYLABS_DEFAULT_ORG_ID.
+        dataset_id (Optional[str]): WhyLabs dataset id to write profiles to.
+            Optional because the preferred way to specify the dataset id is
+            with environment variable WHYLABS_DEFAULT_DATASET_ID.
+        sentiment (bool): Whether to enable sentiment analysis. Defaults to False.
+        toxicity (bool): Whether to enable toxicity analysis. Defaults to False.
+        themes (bool): Whether to enable theme analysis. Defaults to False.
+    """
+
+    def __init__(self, logger: Logger, handler: Any):
+        """Initiate the rolling logger."""
+        super().__init__()
+        if hasattr(handler, "init"):
+            handler.init(self)
+        if hasattr(handler, "_get_callbacks"):
+            self._callbacks = handler._get_callbacks()
+        else:
+            self._callbacks = dict()
+            diagnostic_logger.warning("initialized handler without callbacks.")
+        self._logger = logger
+
+    def flush(self) -> None:
+        """Explicitly write current profile if using a rolling logger."""
+        if self._logger and hasattr(self._logger, "_do_rollover"):
+            self._logger._do_rollover()
+            diagnostic_logger.info("Flushing WhyLabs logger, writing profile...")
+
+    def close(self) -> None:
+        """Close any loggers to allow writing out of any profiles before exiting."""
+        if self._logger and hasattr(self._logger, "close"):
+            self._logger.close()
+            diagnostic_logger.info("Closing WhyLabs logger, see you next time!")
+
+    def __enter__(self) -> WhyLabsCallbackHandler:
+        return self
+
+    def __exit__(
+        self, exception_type: Any, exception_value: Any, traceback: Any
+    ) -> None:
+        self.close()
+
+    @classmethod
+    def from_params(
+        cls,
+        *,
+        api_key: Optional[str] = None,
+        org_id: Optional[str] = None,
+        dataset_id: Optional[str] = None,
+        sentiment: bool = False,
+        toxicity: bool = False,
+        themes: bool = False,
+        logger: Optional[Logger] = None,
+    ) -> WhyLabsCallbackHandler:
+        """Instantiate whylogs Logger from params.
+
+        Args:
+            api_key (Optional[str]): WhyLabs API key. Optional because the preferred
+                way to specify the API key is with environment variable
+                WHYLABS_API_KEY.
+            org_id (Optional[str]): WhyLabs organization id to write profiles to.
+                If not set must be specified in environment variable
+                WHYLABS_DEFAULT_ORG_ID.
+            dataset_id (Optional[str]): The model or dataset this callback is gathering
+                telemetry for. If not set must be specified in environment variable
+                WHYLABS_DEFAULT_DATASET_ID.
+            sentiment (bool): If True will initialize a model to perform
+                sentiment analysis compound score. Defaults to False and will not gather
+                this metric.
+            toxicity (bool): If True will initialize a model to score
+                toxicity. Defaults to False and will not gather this metric.
+            themes (bool): If True will initialize a model to calculate
+                distance to configured themes. Defaults to None and will not gather this
+                metric.
+            logger (Optional[Logger]): If specified will bind the configured logger as
+                the telemetry gathering agent. Defaults to LangKit schema with periodic
+                WhyLabs writer.
+        """
+        # langkit library will import necessary whylogs libraries
+        import_langkit(sentiment=sentiment, toxicity=toxicity, themes=themes)
+
+        why = guard_import("whylogs")
+        get_callback_instance = guard_import(
+            "langkit.callback_handler"
+        ).get_callback_instance
+        WhyLabsWriter = guard_import("whylogs.api.writer.whylabs").WhyLabsWriter
+        udf_schema = guard_import("whylogs.experimental.core.udf_schema").udf_schema
+
+        if logger is None:
+            api_key = api_key or get_from_env("api_key", "WHYLABS_API_KEY")
+            org_id = org_id or get_from_env("org_id", "WHYLABS_DEFAULT_ORG_ID")
+            dataset_id = dataset_id or get_from_env(
+                "dataset_id", "WHYLABS_DEFAULT_DATASET_ID"
+            )
+            whylabs_writer = WhyLabsWriter(
+                api_key=api_key, org_id=org_id, dataset_id=dataset_id
+            )
+
+            whylabs_logger = why.logger(
+                mode="rolling", interval=5, when="M", schema=udf_schema()
+            )
+
+            whylabs_logger.append_writer(writer=whylabs_writer)
+        else:
+            diagnostic_logger.info("Using passed in whylogs logger {logger}")
+            whylabs_logger = logger
+
+        callback_handler_cls = get_callback_instance(logger=whylabs_logger, impl=cls)
+        diagnostic_logger.info(
+            "Started whylogs Logger with WhyLabsWriter and initialized LangKit. 📝"
+        )
+        return callback_handler_cls

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chains/__init__.py

@@ -0,0 +1,24 @@
+"""
+Chains module for langchain_community
+
+This module contains the community chains.
+"""
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.chains.pebblo_retrieval.base import PebbloRetrievalQA
+
+__all__ = ["PebbloRetrievalQA"]
+
+_module_lookup = {
+    "PebbloRetrievalQA": "langchain_community.chains.pebblo_retrieval.base"
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chains/llm_requests.py

@@ -0,0 +1,98 @@
+"""Chain that hits a URL and then uses an LLM to parse results."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from langchain_classic.chains import LLMChain
+from langchain_classic.chains.base import Chain
+from langchain_core.callbacks import CallbackManagerForChainRun
+from pydantic import ConfigDict, Field, model_validator
+
+from langchain_community.utilities.requests import TextRequestsWrapper
+
+DEFAULT_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36"  # noqa: E501
+}
+
+
+class LLMRequestsChain(Chain):
+    """Chain that requests a URL and then uses an LLM to parse results.
+
+    **Security Note**: This chain can make GET requests to arbitrary URLs,
+        including internal URLs.
+
+        Control access to who can run this chain and what network access
+        this chain has.
+
+        See https://python.langchain.com/docs/security for more information.
+    """
+
+    llm_chain: LLMChain
+    requests_wrapper: TextRequestsWrapper = Field(
+        default_factory=lambda: TextRequestsWrapper(headers=DEFAULT_HEADERS),
+        exclude=True,
+    )
+    text_length: int = 8000
+    requests_key: str = "requests_result"  #: :meta private:
+    input_key: str = "url"  #: :meta private:
+    output_key: str = "output"  #: :meta private:
+
+    model_config = ConfigDict(
+        arbitrary_types_allowed=True,
+        extra="forbid",
+    )
+
+    @property
+    def input_keys(self) -> List[str]:
+        """Will be whatever keys the prompt expects.
+
+        :meta private:
+        """
+        return [self.input_key]
+
+    @property
+    def output_keys(self) -> List[str]:
+        """Will always return text key.
+
+        :meta private:
+        """
+        return [self.output_key]
+
+    @model_validator(mode="before")
+    @classmethod
+    def validate_environment(cls, values: Dict) -> Any:
+        """Validate that api key and python package exists in environment."""
+        try:
+            from bs4 import BeautifulSoup  # noqa: F401
+
+        except ImportError:
+            raise ImportError(
+                "Could not import bs4 python package. "
+                "Please install it with `pip install bs4`."
+            )
+        return values
+
+    def _call(
+        self,
+        inputs: Dict[str, Any],
+        run_manager: Optional[CallbackManagerForChainRun] = None,
+    ) -> Dict[str, Any]:
+        from bs4 import BeautifulSoup
+
+        _run_manager = run_manager or CallbackManagerForChainRun.get_noop_manager()
+        # Other keys are assumed to be needed for LLM prediction
+        other_keys = {k: v for k, v in inputs.items() if k != self.input_key}
+        url = inputs[self.input_key]
+        res = self.requests_wrapper.get(url)
+        # extract the text from the html
+        soup = BeautifulSoup(res, "html.parser")  # type: ignore[arg-type]
+        other_keys[self.requests_key] = soup.get_text()[: self.text_length]
+        result = self.llm_chain.predict(
+            callbacks=_run_manager.get_child(), **other_keys
+        )
+        return {self.output_key: result}
+
+    @property
+    def _chain_type(self) -> str:
+        return "llm_requests_chain"

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/__init__.py

@@ -0,0 +1,83 @@
+"""**Chat Loaders** load chat messages from common communications platforms.
+
+Load chat messages from various
+communications platforms such as Facebook Messenger, Telegram, and
+WhatsApp. The loaded chat messages can be used for fine-tuning models.
+
+**Class hierarchy:**
+
+.. code-block::
+
+    BaseChatLoader --> <name>ChatLoader  # Examples: WhatsAppChatLoader, IMessageChatLoader
+
+**Main helpers:**
+
+.. code-block::
+
+    ChatSession
+
+"""  # noqa: E501
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.chat_loaders.base import (
+        BaseChatLoader,
+    )
+    from langchain_community.chat_loaders.facebook_messenger import (
+        FolderFacebookMessengerChatLoader,
+        SingleFileFacebookMessengerChatLoader,
+    )
+    from langchain_community.chat_loaders.gmail import (
+        GMailLoader,
+    )
+    from langchain_community.chat_loaders.imessage import (
+        IMessageChatLoader,
+    )
+    from langchain_community.chat_loaders.langsmith import (
+        LangSmithDatasetChatLoader,
+        LangSmithRunChatLoader,
+    )
+    from langchain_community.chat_loaders.slack import (
+        SlackChatLoader,
+    )
+    from langchain_community.chat_loaders.telegram import (
+        TelegramChatLoader,
+    )
+    from langchain_community.chat_loaders.whatsapp import (
+        WhatsAppChatLoader,
+    )
+
+__all__ = [
+    "BaseChatLoader",
+    "FolderFacebookMessengerChatLoader",
+    "GMailLoader",
+    "IMessageChatLoader",
+    "LangSmithDatasetChatLoader",
+    "LangSmithRunChatLoader",
+    "SingleFileFacebookMessengerChatLoader",
+    "SlackChatLoader",
+    "TelegramChatLoader",
+    "WhatsAppChatLoader",
+]
+
+_module_lookup = {
+    "BaseChatLoader": "langchain_core.chat_loaders",
+    "FolderFacebookMessengerChatLoader": "langchain_community.chat_loaders.facebook_messenger",  # noqa: E501
+    "GMailLoader": "langchain_community.chat_loaders.gmail",
+    "IMessageChatLoader": "langchain_community.chat_loaders.imessage",
+    "LangSmithDatasetChatLoader": "langchain_community.chat_loaders.langsmith",
+    "LangSmithRunChatLoader": "langchain_community.chat_loaders.langsmith",
+    "SingleFileFacebookMessengerChatLoader": "langchain_community.chat_loaders.facebook_messenger",  # noqa: E501
+    "SlackChatLoader": "langchain_community.chat_loaders.slack",
+    "TelegramChatLoader": "langchain_community.chat_loaders.telegram",
+    "WhatsAppChatLoader": "langchain_community.chat_loaders.whatsapp",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/base.py

@@ -0,0 +1,3 @@
+from langchain_core.chat_loaders import BaseChatLoader
+
+__all__ = ["BaseChatLoader"]

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/facebook_messenger.py

@@ -0,0 +1,78 @@
+import json
+import logging
+from pathlib import Path
+from typing import Iterator, Union
+
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import HumanMessage
+
+logger = logging.getLogger(__file__)
+
+
+class SingleFileFacebookMessengerChatLoader(BaseChatLoader):
+    """Load `Facebook Messenger` chat data from a single file.
+
+    Args:
+        path (Union[Path, str]): The path to the chat file.
+
+    """
+
+    def __init__(self, path: Union[Path, str]) -> None:
+        super().__init__()
+        self.file_path = path if isinstance(path, Path) else Path(path)
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """Lazy loads the chat data from the file.
+
+        Yields:
+            ChatSession: A chat session containing the loaded messages.
+
+        """
+        with open(self.file_path) as f:
+            data = json.load(f)
+        sorted_data = sorted(data["messages"], key=lambda x: x["timestamp_ms"])
+        messages = []
+        for index, m in enumerate(sorted_data):
+            if "content" not in m:
+                logger.info(
+                    f"""Skipping Message No.
+                    {index + 1} as no content is present in the message"""
+                )
+                continue
+            messages.append(
+                HumanMessage(
+                    content=m["content"], additional_kwargs={"sender": m["sender_name"]}
+                )
+            )
+        yield ChatSession(messages=messages)
+
+
+class FolderFacebookMessengerChatLoader(BaseChatLoader):
+    """Load `Facebook Messenger` chat data from a folder.
+
+    Args:
+        path (Union[str, Path]): The path to the directory
+            containing the chat files.
+
+    """
+
+    def __init__(self, path: Union[str, Path]) -> None:
+        super().__init__()
+        self.directory_path = Path(path) if isinstance(path, str) else path
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """Lazy loads the chat data from the folder.
+
+        Yields:
+            ChatSession: A chat session containing the loaded messages.
+
+        """
+        inbox_path = self.directory_path / "inbox"
+        for _dir in inbox_path.iterdir():
+            if _dir.is_dir():
+                for _file in _dir.iterdir():
+                    if _file.suffix.lower() == ".json":
+                        file_loader = SingleFileFacebookMessengerChatLoader(path=_file)
+                        for result in file_loader.lazy_load():
+                            yield result

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/gmail.py

@@ -0,0 +1,117 @@
+import base64
+import re
+from typing import Any, Iterator
+
+from langchain_core._api.deprecation import deprecated
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import HumanMessage
+
+
+def _extract_email_content(msg: Any) -> HumanMessage:
+    from_email = None
+    for values in msg["payload"]["headers"]:
+        name = values["name"]
+        if name == "From":
+            from_email = values["value"]
+    if from_email is None:
+        raise ValueError
+    for part in msg["payload"]["parts"]:
+        if part["mimeType"] == "text/plain":
+            data = part["body"]["data"]
+            data = base64.urlsafe_b64decode(data).decode("utf-8")
+            # Regular expression to split the email body at the first
+            # occurrence of a line that starts with "On ... wrote:"
+            pattern = re.compile(r"\r\nOn .+(\r\n)*wrote:\r\n")
+            # Split the email body and extract the first part
+            newest_response = re.split(pattern, data)[0]
+            message = HumanMessage(
+                content=newest_response, additional_kwargs={"sender": from_email}
+            )
+            return message
+    raise ValueError
+
+
+def _get_message_data(service: Any, message: Any) -> ChatSession:
+    msg = service.users().messages().get(userId="me", id=message["id"]).execute()
+    message_content = _extract_email_content(msg)
+    in_reply_to = None
+    email_data = msg["payload"]["headers"]
+    for values in email_data:
+        name = values["name"]
+        if name == "In-Reply-To":
+            in_reply_to = values["value"]
+    if in_reply_to is None:
+        raise ValueError
+
+    thread_id = msg["threadId"]
+
+    thread = service.users().threads().get(userId="me", id=thread_id).execute()
+    messages = thread["messages"]
+
+    response_email = None
+    for message in messages:
+        email_data = message["payload"]["headers"]
+        for values in email_data:
+            if values["name"] == "Message-ID":
+                message_id = values["value"]
+                if message_id == in_reply_to:
+                    response_email = message
+    if response_email is None:
+        raise ValueError
+    starter_content = _extract_email_content(response_email)
+    return ChatSession(messages=[starter_content, message_content])
+
+
+@deprecated(
+    since="0.0.32",
+    removal="1.0",
+    alternative_import="langchain_google_community.GMailLoader",
+)
+class GMailLoader(BaseChatLoader):
+    """Load data from `GMail`.
+
+    There are many ways you could want to load data from GMail.
+    This loader is currently fairly opinionated in how to do so.
+    The way it does it is it first looks for all messages that you have sent.
+    It then looks for messages where you are responding to a previous email.
+    It then fetches that previous email, and creates a training example
+    of that email, followed by your email.
+
+    Note that there are clear limitations here. For example,
+    all examples created are only looking at the previous email for context.
+
+    To use:
+
+    - Set up a Google Developer Account:
+        Go to the Google Developer Console, create a project,
+        and enable the Gmail API for that project.
+        This will give you a credentials.json file that you'll need later.
+    """
+
+    def __init__(self, creds: Any, n: int = 100, raise_error: bool = False) -> None:
+        super().__init__()
+        self.creds = creds
+        self.n = n
+        self.raise_error = raise_error
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        from googleapiclient.discovery import build
+
+        service = build("gmail", "v1", credentials=self.creds)
+        results = (
+            service.users()
+            .messages()
+            .list(userId="me", labelIds=["SENT"], maxResults=self.n)
+            .execute()
+        )
+        messages = results.get("messages", [])
+        for message in messages:
+            try:
+                yield _get_message_data(service, message)
+            except Exception as e:
+                # TODO: handle errors better
+                if self.raise_error:
+                    raise e
+                else:
+                    pass

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/imessage.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+from datetime import datetime
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterator, List, Optional, Union
+
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import HumanMessage
+
+if TYPE_CHECKING:
+    import sqlite3
+
+
+def nanoseconds_from_2001_to_datetime(nanoseconds: int) -> datetime:
+    """Convert nanoseconds since 2001 to a datetime object.
+
+    Args:
+        nanoseconds (int): Nanoseconds since January 1, 2001.
+
+    Returns:
+        datetime: Datetime object.
+    """
+    # Convert nanoseconds to seconds (1 second = 1e9 nanoseconds)
+    timestamp_in_seconds = nanoseconds / 1e9
+
+    # The reference date is January 1, 2001, in Unix time
+    reference_date_seconds = datetime(2001, 1, 1).timestamp()
+
+    # Calculate the actual timestamp by adding the reference date
+    actual_timestamp = reference_date_seconds + timestamp_in_seconds
+
+    # Convert to a datetime object
+    return datetime.fromtimestamp(actual_timestamp)
+
+
+class IMessageChatLoader(BaseChatLoader):
+    """Load chat sessions from the `iMessage` chat.db SQLite file.
+
+    It only works on macOS when you have iMessage enabled and have the chat.db file.
+
+    The chat.db file is likely located at ~/Library/Messages/chat.db. However, your
+    terminal may not have permission to access this file. To resolve this, you can
+    copy the file to a different location, change the permissions of the file, or
+    grant full disk access for your terminal emulator
+    in System Settings > Security and Privacy > Full Disk Access.
+    """
+
+    def __init__(self, path: Optional[Union[str, Path]] = None):
+        """
+        Initialize the IMessageChatLoader.
+
+        Args:
+            path (str or Path, optional): Path to the chat.db SQLite file.
+                Defaults to None, in which case the default path
+                ~/Library/Messages/chat.db will be used.
+        """
+        if path is None:
+            path = Path.home() / "Library" / "Messages" / "chat.db"
+        self.db_path = path if isinstance(path, Path) else Path(path)
+        if not self.db_path.exists():
+            raise FileNotFoundError(f"File {self.db_path} not found")
+        try:
+            import sqlite3  # noqa: F401
+        except ImportError as e:
+            raise ImportError(
+                "The sqlite3 module is required to load iMessage chats.\n"
+                "Please install it with `pip install pysqlite3`"
+            ) from e
+
+    @staticmethod
+    def _parse_attributed_body(attributed_body: bytes) -> str:
+        """
+        Parse the attributedBody field of the message table
+        for the text content of the message.
+
+        The attributedBody field is a binary blob that contains
+        the message content after the byte string b"NSString":
+
+                              5 bytes      1-3 bytes    `len` bytes
+        ... | b"NSString" |   preamble   |   `len`   |    contents    | ...
+
+        The 5 preamble bytes are always b"\x01\x94\x84\x01+"
+
+        The size of `len` is either 1 byte or 3 bytes:
+        - If the first byte in `len` is b"\x81" then `len` is 3 bytes long.
+          So the message length is the 2 bytes after, in little Endian.
+        - Otherwise, the size of `len` is 1 byte, and the message length is
+          that byte.
+
+        Args:
+            attributed_body (bytes): attributedBody field of the message table.
+        Return:
+            str: Text content of the message.
+        """
+        content = attributed_body.split(b"NSString")[1][5:]
+        length, start = content[0], 1
+        if content[0] == 129:
+            length, start = int.from_bytes(content[1:3], "little"), 3
+        return content[start : start + length].decode("utf-8", errors="ignore")
+
+    @staticmethod
+    def _get_session_query(use_chat_handle_table: bool) -> str:
+        # Messages sent pre OSX 12 require a join through the chat_handle_join table
+        # However, the table doesn't exist if database created with OSX 12 or above.
+
+        joins_w_chat_handle = """
+            JOIN chat_handle_join ON
+                 chat_message_join.chat_id = chat_handle_join.chat_id
+            JOIN handle ON
+                 handle.ROWID = chat_handle_join.handle_id"""
+
+        joins_no_chat_handle = """
+            JOIN handle ON message.handle_id = handle.ROWID
+        """
+
+        joins = joins_w_chat_handle if use_chat_handle_table else joins_no_chat_handle
+
+        return f"""
+            SELECT  message.date,
+                    handle.id,
+                    message.text,
+                    message.is_from_me,
+                    message.attributedBody
+            FROM message
+            JOIN chat_message_join ON
+                 message.ROWID = chat_message_join.message_id
+            {joins}
+            WHERE chat_message_join.chat_id = ?
+            ORDER BY message.date ASC;
+        """
+
+    def _load_single_chat_session(
+        self, cursor: "sqlite3.Cursor", use_chat_handle_table: bool, chat_id: int
+    ) -> ChatSession:
+        """
+        Load a single chat session from the iMessage chat.db.
+
+        Args:
+            cursor: SQLite cursor object.
+            chat_id (int): ID of the chat session to load.
+
+        Returns:
+            ChatSession: Loaded chat session.
+        """
+        results: List[HumanMessage] = []
+
+        query = self._get_session_query(use_chat_handle_table)
+        cursor.execute(query, (chat_id,))
+        messages = cursor.fetchall()
+
+        for date, sender, text, is_from_me, attributedBody in messages:
+            if text:
+                content = text
+            elif attributedBody:
+                content = self._parse_attributed_body(attributedBody)
+            else:  # Skip messages with no content
+                continue
+
+            results.append(
+                HumanMessage(
+                    role=sender,
+                    content=content,
+                    additional_kwargs={
+                        "message_time": date,
+                        "message_time_as_datetime": nanoseconds_from_2001_to_datetime(
+                            date
+                        ),
+                        "sender": sender,
+                        "is_from_me": bool(is_from_me),
+                    },
+                )
+            )
+
+        return ChatSession(messages=results)
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """
+        Lazy load the chat sessions from the iMessage chat.db
+        and yield them in the required format.
+
+        Yields:
+            ChatSession: Loaded chat session.
+        """
+        import sqlite3
+
+        try:
+            conn = sqlite3.connect(self.db_path)
+        except sqlite3.OperationalError as e:
+            raise ValueError(
+                f"Could not open iMessage DB file {self.db_path}.\n"
+                "Make sure your terminal emulator has disk access to this file.\n"
+                "   You can either copy the DB file to an accessible location"
+                " or grant full disk access for your terminal emulator."
+                "  You can grant full disk access for your terminal emulator"
+                " in System Settings > Security and Privacy > Full Disk Access."
+            ) from e
+        cursor = conn.cursor()
+
+        # See if chat_handle_join table exists:
+        query = """SELECT name FROM sqlite_master
+                   WHERE type='table' AND name='chat_handle_join';"""
+
+        cursor.execute(query)
+        is_chat_handle_join_exists = cursor.fetchone()
+
+        # Fetch the list of chat IDs sorted by time (most recent first)
+        query = """SELECT chat_id
+        FROM message
+        JOIN chat_message_join ON message.ROWID = chat_message_join.message_id
+        GROUP BY chat_id
+        ORDER BY MAX(date) DESC;"""
+        cursor.execute(query)
+        chat_ids = [row[0] for row in cursor.fetchall()]
+
+        for chat_id in chat_ids:
+            yield self._load_single_chat_session(
+                cursor, is_chat_handle_join_exists, chat_id
+            )
+
+        conn.close()

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/langsmith.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Dict, Iterable, Iterator, List, Optional, Union, cast
+
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.load.load import load
+
+if TYPE_CHECKING:
+    from langsmith.client import Client
+    from langsmith.schemas import Run
+
+logger = logging.getLogger(__name__)
+
+
+class LangSmithRunChatLoader(BaseChatLoader):
+    """
+    Load chat sessions from a list of LangSmith "llm" runs.
+
+    Attributes:
+        runs (Iterable[Union[str, Run]]): The list of LLM run IDs or run objects.
+        client (Client): Instance of LangSmith client for fetching data.
+    """
+
+    def __init__(
+        self, runs: Iterable[Union[str, Run]], client: Optional["Client"] = None
+    ):
+        """
+        Initialize a new LangSmithRunChatLoader instance.
+
+        :param runs: List of LLM run IDs or run objects.
+        :param client: An instance of LangSmith client, if not provided,
+            a new client instance will be created.
+        """
+        from langsmith.client import Client
+
+        self.runs = runs
+        self.client = client or Client()
+
+    @staticmethod
+    def _load_single_chat_session(llm_run: "Run") -> ChatSession:
+        """
+        Convert an individual LangSmith LLM run to a ChatSession.
+
+        :param llm_run: The LLM run object.
+        :return: A chat session representing the run's data.
+        """
+        chat_session = LangSmithRunChatLoader._get_messages_from_llm_run(llm_run)
+        functions = LangSmithRunChatLoader._get_functions_from_llm_run(llm_run)
+        if functions:
+            chat_session["functions"] = functions
+        return chat_session
+
+    @staticmethod
+    def _get_messages_from_llm_run(llm_run: "Run") -> ChatSession:
+        """
+        Extract messages from a LangSmith LLM run.
+
+        :param llm_run: The LLM run object.
+        :return: ChatSession with the extracted messages.
+        """
+        if llm_run.run_type != "llm":
+            raise ValueError(f"Expected run of type llm. Got: {llm_run.run_type}")
+        if "messages" not in llm_run.inputs:
+            raise ValueError(f"Run has no 'messages' inputs. Got {llm_run.inputs}")
+        if not llm_run.outputs:
+            raise ValueError("Cannot convert pending run")
+        messages = load(llm_run.inputs)["messages"]
+        message_chunk = load(llm_run.outputs)["generations"][0]["message"]
+        return ChatSession(messages=messages + [message_chunk])
+
+    @staticmethod
+    def _get_functions_from_llm_run(llm_run: "Run") -> Optional[List[Dict]]:
+        """
+        Extract functions from a LangSmith LLM run if they exist.
+
+        :param llm_run: The LLM run object.
+        :return: Functions from the run or None.
+        """
+        if llm_run.run_type != "llm":
+            raise ValueError(f"Expected run of type llm. Got: {llm_run.run_type}")
+        return (llm_run.extra or {}).get("invocation_params", {}).get("functions")
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """
+        Lazy load the chat sessions from the iterable of run IDs.
+
+        This method fetches the runs and converts them to chat sessions on-the-fly,
+        yielding one session at a time.
+
+        :return: Iterator of chat sessions containing messages.
+        """
+        from langsmith.schemas import Run
+
+        for run_obj in self.runs:
+            try:
+                if hasattr(run_obj, "id"):
+                    run = run_obj
+                else:
+                    run = self.client.read_run(run_obj)
+                session = self._load_single_chat_session(cast(Run, run))
+                yield session
+            except ValueError as e:
+                logger.warning(f"Could not load run {run_obj}: {repr(e)}")
+                continue
+
+
+class LangSmithDatasetChatLoader(BaseChatLoader):
+    """
+    Load chat sessions from a LangSmith dataset with the "chat" data type.
+
+    Attributes:
+        dataset_name (str): The name of the LangSmith dataset.
+        client (Client): Instance of LangSmith client for fetching data.
+    """
+
+    def __init__(self, *, dataset_name: str, client: Optional["Client"] = None):
+        """
+        Initialize a new LangSmithChatDatasetLoader instance.
+
+        :param dataset_name: The name of the LangSmith dataset.
+        :param client: An instance of LangSmith client; if not provided,
+            a new client instance will be created.
+        """
+        try:
+            from langsmith.client import Client
+        except ImportError as e:
+            raise ImportError(
+                "The LangSmith client is required to load LangSmith datasets.\n"
+                "Please install it with `pip install langsmith`"
+            ) from e
+
+        self.dataset_name = dataset_name
+        self.client = client or Client()
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """
+        Lazy load the chat sessions from the specified LangSmith dataset.
+
+        This method fetches the chat data from the dataset and
+        converts each data point to chat sessions on-the-fly,
+        yielding one session at a time.
+
+        :return: Iterator of chat sessions containing messages.
+        """
+        from langchain_community.adapters import openai as oai_adapter
+
+        data = self.client.read_dataset_openai_finetuning(
+            dataset_name=self.dataset_name
+        )
+        for data_point in data:
+            yield ChatSession(
+                messages=[
+                    oai_adapter.convert_dict_to_message(m)
+                    for m in data_point.get("messages", [])
+                ],
+                functions=data_point.get("functions"),
+            )

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/slack.py

@@ -0,0 +1,87 @@
+import json
+import logging
+import re
+import zipfile
+from pathlib import Path
+from typing import Dict, Iterator, List, Union
+
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import AIMessage, HumanMessage
+
+logger = logging.getLogger(__name__)
+
+
+class SlackChatLoader(BaseChatLoader):
+    """Load `Slack` conversations from a dump zip file."""
+
+    def __init__(
+        self,
+        path: Union[str, Path],
+    ):
+        """
+        Initialize the chat loader with the path to the exported Slack dump zip file.
+
+        :param path: Path to the exported Slack dump zip file.
+        """
+        self.zip_path = path if isinstance(path, Path) else Path(path)
+        if not self.zip_path.exists():
+            raise FileNotFoundError(f"File {self.zip_path} not found")
+
+    @staticmethod
+    def _load_single_chat_session(messages: List[Dict]) -> ChatSession:
+        results: List[Union[AIMessage, HumanMessage]] = []
+        previous_sender = None
+        for message in messages:
+            if not isinstance(message, dict):
+                continue
+            text = message.get("text", "")
+            timestamp = message.get("ts", "")
+            sender = message.get("user", "")
+            if not sender:
+                continue
+            skip_pattern = re.compile(
+                r"<@U\d+> has joined the channel", flags=re.IGNORECASE
+            )
+            if skip_pattern.match(text):
+                continue
+            if sender == previous_sender:
+                results[-1].content += "\n\n" + text
+                results[-1].additional_kwargs["events"].append(
+                    {"message_time": timestamp}
+                )
+            else:
+                results.append(
+                    HumanMessage(
+                        role=sender,
+                        content=text,
+                        additional_kwargs={
+                            "sender": sender,
+                            "events": [{"message_time": timestamp}],
+                        },
+                    )
+                )
+            previous_sender = sender
+        return ChatSession(messages=results)
+
+    @staticmethod
+    def _read_json(zip_file: zipfile.ZipFile, file_path: str) -> List[dict]:
+        """Read JSON data from a zip subfile."""
+        with zip_file.open(file_path, "r") as f:
+            data = json.load(f)
+        if not isinstance(data, list):
+            raise ValueError(f"Expected list of dictionaries, got {type(data)}")
+        return data
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """
+        Lazy load the chat sessions from the Slack dump file and yield them
+        in the required format.
+
+        :return: Iterator of chat sessions containing messages.
+        """
+        with zipfile.ZipFile(str(self.zip_path), "r") as zip_file:
+            for file_path in zip_file.namelist():
+                if file_path.endswith(".json"):
+                    messages = self._read_json(zip_file, file_path)
+                    yield self._load_single_chat_session(messages)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/telegram.py

@@ -0,0 +1,155 @@
+import json
+import logging
+import os
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Iterator, List, Union
+
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import AIMessage, BaseMessage, HumanMessage
+
+logger = logging.getLogger(__name__)
+
+
+class TelegramChatLoader(BaseChatLoader):
+    """Load `telegram` conversations to LangChain chat messages.
+
+    To export, use the Telegram Desktop app from
+    https://desktop.telegram.org/, select a conversation, click the three dots
+    in the top right corner, and select "Export chat history". Then select
+    "Machine-readable JSON" (preferred) to export. Note: the 'lite' versions of
+    the desktop app (like "Telegram for MacOS") do not support exporting chat
+    history.
+    """
+
+    def __init__(
+        self,
+        path: Union[str, Path],
+    ):
+        """Initialize the TelegramChatLoader.
+
+        Args:
+            path (Union[str, Path]): Path to the exported Telegram chat zip,
+                 directory, json, or HTML file.
+        """
+        self.path = path if isinstance(path, str) else str(path)
+
+    @staticmethod
+    def _load_single_chat_session_html(file_path: str) -> ChatSession:
+        """Load a single chat session from an HTML file.
+
+        Args:
+            file_path (str): Path to the HTML file.
+
+        Returns:
+            ChatSession: The loaded chat session.
+        """
+        try:
+            from bs4 import BeautifulSoup
+        except ImportError:
+            raise ImportError(
+                "Please install the 'beautifulsoup4' package to load"
+                " Telegram HTML files. You can do this by running"
+                "'pip install beautifulsoup4' in your terminal."
+            )
+        with open(file_path, "r", encoding="utf-8") as file:
+            soup = BeautifulSoup(file, "html.parser")
+
+        results: List[Union[HumanMessage, AIMessage]] = []
+        previous_sender = None
+        for message in soup.select(".message.default"):
+            timestamp = message.select_one(".pull_right.date.details")["title"]  # type: ignore[index]
+            from_name_element = message.select_one(".from_name")
+            if from_name_element is None and previous_sender is None:
+                logger.debug("from_name not found in message")
+                continue
+            elif from_name_element is None:
+                from_name = previous_sender
+            else:
+                from_name = from_name_element.text.strip()
+            text = message.select_one(".text").text.strip()  # type: ignore[union-attr]
+            results.append(
+                HumanMessage(
+                    content=text,
+                    additional_kwargs={
+                        "sender": from_name,
+                        "events": [{"message_time": timestamp}],
+                    },
+                )
+            )
+            previous_sender = from_name
+
+        return ChatSession(messages=results)
+
+    @staticmethod
+    def _load_single_chat_session_json(file_path: str) -> ChatSession:
+        """Load a single chat session from a JSON file.
+
+        Args:
+            file_path (str): Path to the JSON file.
+
+        Returns:
+            ChatSession: The loaded chat session.
+        """
+        with open(file_path, "r", encoding="utf-8") as file:
+            data = json.load(file)
+
+        messages = data.get("messages", [])
+        results: List[BaseMessage] = []
+        for message in messages:
+            text = message.get("text", "")
+            timestamp = message.get("date", "")
+            from_name = message.get("from", "")
+            if from_name is None:
+                from_name = "Deleted Account"
+
+            results.append(
+                HumanMessage(
+                    content=text,
+                    additional_kwargs={
+                        "sender": from_name,
+                        "events": [{"message_time": timestamp}],
+                    },
+                )
+            )
+
+        return ChatSession(messages=results)
+
+    @staticmethod
+    def _iterate_files(path: str) -> Iterator[str]:
+        """Iterate over files in a directory or zip file.
+
+        Args:
+            path (str): Path to the directory or zip file.
+
+        Yields:
+            str: Path to each file.
+        """
+        if os.path.isfile(path) and path.endswith((".html", ".json")):
+            yield path
+        elif os.path.isdir(path):
+            for root, _, files in os.walk(path):
+                for file in files:
+                    if file.endswith((".html", ".json")):
+                        yield os.path.join(root, file)
+        elif zipfile.is_zipfile(path):
+            with zipfile.ZipFile(path) as zip_file:
+                for file in zip_file.namelist():
+                    if file.endswith((".html", ".json")):
+                        with tempfile.TemporaryDirectory() as temp_dir:
+                            yield zip_file.extract(file, path=temp_dir)
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """Lazy load the messages from the chat file and yield them
+        in as chat sessions.
+
+        Yields:
+            ChatSession: The loaded chat session.
+        """
+        for file_path in self._iterate_files(self.path):
+            if file_path.endswith(".html"):
+                yield self._load_single_chat_session_html(file_path)
+            elif file_path.endswith(".json"):
+                yield self._load_single_chat_session_json(file_path)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/utils.py

@@ -0,0 +1,104 @@
+"""Utilities for chat loaders."""
+
+from copy import deepcopy
+from typing import Iterable, Iterator, List
+
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import AIMessage, BaseMessage
+
+
+def merge_chat_runs_in_session(
+    chat_session: ChatSession, delimiter: str = "\n\n"
+) -> ChatSession:
+    """Merge chat runs together in a chat session.
+
+    A chat run is a sequence of messages from the same sender.
+
+    Args:
+        chat_session: A chat session.
+
+    Returns:
+        A chat session with merged chat runs.
+    """
+    messages: List[BaseMessage] = []
+    for message in chat_session["messages"]:
+        if isinstance(message.content, list):
+            text = ""
+            for content in message.content:
+                if isinstance(content, dict):
+                    text += content.get("text", "") or ""
+                else:
+                    text += content
+            message.content = text
+        if not isinstance(message.content, str):
+            raise ValueError(
+                "Chat Loaders only support messages with content type string, "
+                f"got {message.content}"
+            )
+        if not messages:
+            messages.append(deepcopy(message))
+        elif (
+            isinstance(message, type(messages[-1]))
+            and messages[-1].additional_kwargs.get("sender") is not None
+            and messages[-1].additional_kwargs["sender"]
+            == message.additional_kwargs.get("sender")
+        ):
+            if not isinstance(messages[-1].content, str):
+                raise ValueError(
+                    "Chat Loaders only support messages with content type string, "
+                    f"got {messages[-1].content}"
+                )
+            messages[-1].content = (
+                messages[-1].content + delimiter + message.content
+            ).strip()
+            messages[-1].additional_kwargs.get("events", []).extend(
+                message.additional_kwargs.get("events") or []
+            )
+        else:
+            messages.append(deepcopy(message))
+    return ChatSession(messages=messages)
+
+
+def merge_chat_runs(chat_sessions: Iterable[ChatSession]) -> Iterator[ChatSession]:
+    """Merge chat runs together.
+
+    A chat run is a sequence of messages from the same sender.
+
+    Args:
+        chat_sessions: A list of chat sessions.
+
+    Returns:
+        A list of chat sessions with merged chat runs.
+    """
+    for chat_session in chat_sessions:
+        yield merge_chat_runs_in_session(chat_session)
+
+
+def map_ai_messages_in_session(chat_sessions: ChatSession, sender: str) -> ChatSession:
+    """Convert messages from the specified 'sender' to AI messages.
+
+    This is useful for fine-tuning the AI to adapt to your voice.
+    """
+    messages = []
+    num_converted = 0
+    for message in chat_sessions["messages"]:
+        if message.additional_kwargs.get("sender") == sender:
+            message = AIMessage(
+                content=message.content,
+                additional_kwargs=message.additional_kwargs.copy(),
+                example=getattr(message, "example", None),
+            )
+            num_converted += 1
+        messages.append(message)
+    return ChatSession(messages=messages)
+
+
+def map_ai_messages(
+    chat_sessions: Iterable[ChatSession], sender: str
+) -> Iterator[ChatSession]:
+    """Convert messages from the specified 'sender' to AI messages.
+
+    This is useful for fine-tuning the AI to adapt to your voice.
+    """
+    for chat_session in chat_sessions:
+        yield map_ai_messages_in_session(chat_session, sender)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_loaders/whatsapp.py

@@ -0,0 +1,119 @@
+import logging
+import os
+import re
+import zipfile
+from typing import Iterator, List, Union
+
+from langchain_core.chat_loaders import BaseChatLoader
+from langchain_core.chat_sessions import ChatSession
+from langchain_core.messages import AIMessage, HumanMessage
+
+logger = logging.getLogger(__name__)
+
+
+class WhatsAppChatLoader(BaseChatLoader):
+    """Load `WhatsApp` conversations from a dump zip file or directory."""
+
+    def __init__(self, path: str):
+        """Initialize the WhatsAppChatLoader.
+
+        Args:
+            path (str): Path to the exported WhatsApp chat
+                zip directory, folder, or file.
+
+        To generate the dump, open the chat, click the three dots in the top
+        right corner, and select "More". Then select "Export chat" and
+        choose "Without media".
+        """
+        self.path = path
+        ignore_lines = [
+            "This message was deleted",
+            "<Media omitted>",
+            "image omitted",
+            "Messages and calls are end-to-end encrypted. No one outside of this chat,"
+            " not even WhatsApp, can read or listen to them.",
+        ]
+        self._ignore_lines = re.compile(
+            r"(" + "|".join([r"\u200E*" + line for line in ignore_lines]) + r")",
+            flags=re.IGNORECASE,
+        )
+        self._message_line_regex = re.compile(
+            r"\u200E*\[?(\d{1,2}/\d{1,2}/\d{2,4}, \d{1,2}:\d{2}:\d{2} (?:AM|PM))\]?[ \u200E]*([^:]+): (.+)",  # noqa
+            flags=re.IGNORECASE,
+        )
+
+    def _load_single_chat_session(self, file_path: str) -> ChatSession:
+        """Load a single chat session from a file.
+
+        Args:
+            file_path (str): Path to the chat file.
+
+        Returns:
+            ChatSession: The loaded chat session.
+        """
+        with open(file_path, "r", encoding="utf-8") as file:
+            txt = file.read()
+
+        # Split messages by newlines, but keep multi-line messages grouped
+        chat_lines: List[str] = []
+        current_message = ""
+        for line in txt.split("\n"):
+            if self._message_line_regex.match(line):
+                if current_message:
+                    chat_lines.append(current_message)
+                current_message = line
+            else:
+                current_message += " " + line.strip()
+        if current_message:
+            chat_lines.append(current_message)
+        results: List[Union[HumanMessage, AIMessage]] = []
+        for line in chat_lines:
+            result = self._message_line_regex.match(line.strip())
+            if result:
+                timestamp, sender, text = result.groups()
+                if not self._ignore_lines.match(text.strip()):
+                    results.append(
+                        HumanMessage(
+                            role=sender,
+                            content=text,
+                            additional_kwargs={
+                                "sender": sender,
+                                "events": [{"message_time": timestamp}],
+                            },
+                        )
+                    )
+            else:
+                logger.debug(f"Could not parse line: {line}")
+        return ChatSession(messages=results)
+
+    @staticmethod
+    def _iterate_files(path: str) -> Iterator[str]:
+        """Iterate over the files in a directory or zip file.
+
+        Args:
+            path (str): Path to the directory or zip file.
+
+        Yields:
+            str: The path to each file.
+        """
+        if os.path.isfile(path):
+            yield path
+        elif os.path.isdir(path):
+            for root, _, files in os.walk(path):
+                for file in files:
+                    if file.endswith(".txt"):
+                        yield os.path.join(root, file)
+        elif zipfile.is_zipfile(path):
+            with zipfile.ZipFile(path) as zip_file:
+                for file in zip_file.namelist():
+                    if file.endswith(".txt"):
+                        yield zip_file.extract(file)
+
+    def lazy_load(self) -> Iterator[ChatSession]:
+        """Lazy load the messages from the chat file and yield
+        them as chat sessions.
+
+        Yields:
+            Iterator[ChatSession]: The loaded chat sessions.
+        """
+        yield self._load_single_chat_session(self.path)

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_message_histories/__init__.py

@@ -0,0 +1,149 @@
+"""**Chat message history** stores a history of the message interactions in a chat.
+
+
+**Class hierarchy:**
+
+.. code-block::
+
+    BaseChatMessageHistory --> <name>ChatMessageHistory  # Examples: FileChatMessageHistory, PostgresChatMessageHistory
+
+**Main helpers:**
+
+.. code-block::
+
+    AIMessage, HumanMessage, BaseMessage
+
+"""  # noqa: E501
+
+import importlib
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from langchain_community.chat_message_histories.astradb import (
+        AstraDBChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.cassandra import (
+        CassandraChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.cosmos_db import (
+        CosmosDBChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.dynamodb import (
+        DynamoDBChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.elasticsearch import (
+        ElasticsearchChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.file import (
+        FileChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.firestore import (
+        FirestoreChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.in_memory import (
+        ChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.kafka import (
+        KafkaChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.momento import (
+        MomentoChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.mongodb import (
+        MongoDBChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.neo4j import (
+        Neo4jChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.postgres import (
+        PostgresChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.redis import (
+        RedisChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.rocksetdb import (
+        RocksetChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.singlestoredb import (
+        SingleStoreDBChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.sql import (
+        SQLChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.streamlit import (
+        StreamlitChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.tidb import (
+        TiDBChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.upstash_redis import (
+        UpstashRedisChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.xata import (
+        XataChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.zep import (
+        ZepChatMessageHistory,
+    )
+    from langchain_community.chat_message_histories.zep_cloud import (
+        ZepCloudChatMessageHistory,
+    )
+
+__all__ = [
+    "AstraDBChatMessageHistory",
+    "CassandraChatMessageHistory",
+    "ChatMessageHistory",
+    "CosmosDBChatMessageHistory",
+    "DynamoDBChatMessageHistory",
+    "ElasticsearchChatMessageHistory",
+    "FileChatMessageHistory",
+    "FirestoreChatMessageHistory",
+    "MomentoChatMessageHistory",
+    "MongoDBChatMessageHistory",
+    "Neo4jChatMessageHistory",
+    "PostgresChatMessageHistory",
+    "RedisChatMessageHistory",
+    "RocksetChatMessageHistory",
+    "SQLChatMessageHistory",
+    "SingleStoreDBChatMessageHistory",
+    "StreamlitChatMessageHistory",
+    "TiDBChatMessageHistory",
+    "UpstashRedisChatMessageHistory",
+    "XataChatMessageHistory",
+    "ZepChatMessageHistory",
+    "ZepCloudChatMessageHistory",
+    "KafkaChatMessageHistory",
+]
+
+_module_lookup = {
+    "AstraDBChatMessageHistory": "langchain_community.chat_message_histories.astradb",
+    "CassandraChatMessageHistory": "langchain_community.chat_message_histories.cassandra",  # noqa: E501
+    "ChatMessageHistory": "langchain_community.chat_message_histories.in_memory",
+    "CosmosDBChatMessageHistory": "langchain_community.chat_message_histories.cosmos_db",  # noqa: E501
+    "DynamoDBChatMessageHistory": "langchain_community.chat_message_histories.dynamodb",
+    "ElasticsearchChatMessageHistory": "langchain_community.chat_message_histories.elasticsearch",  # noqa: E501
+    "FileChatMessageHistory": "langchain_community.chat_message_histories.file",
+    "FirestoreChatMessageHistory": "langchain_community.chat_message_histories.firestore",  # noqa: E501
+    "MomentoChatMessageHistory": "langchain_community.chat_message_histories.momento",
+    "MongoDBChatMessageHistory": "langchain_community.chat_message_histories.mongodb",
+    "Neo4jChatMessageHistory": "langchain_community.chat_message_histories.neo4j",
+    "PostgresChatMessageHistory": "langchain_community.chat_message_histories.postgres",
+    "RedisChatMessageHistory": "langchain_community.chat_message_histories.redis",
+    "RocksetChatMessageHistory": "langchain_community.chat_message_histories.rocksetdb",
+    "SQLChatMessageHistory": "langchain_community.chat_message_histories.sql",
+    "SingleStoreDBChatMessageHistory": "langchain_community.chat_message_histories.singlestoredb",  # noqa: E501
+    "StreamlitChatMessageHistory": "langchain_community.chat_message_histories.streamlit",  # noqa: E501
+    "TiDBChatMessageHistory": "langchain_community.chat_message_histories.tidb",
+    "UpstashRedisChatMessageHistory": "langchain_community.chat_message_histories.upstash_redis",  # noqa: E501
+    "XataChatMessageHistory": "langchain_community.chat_message_histories.xata",
+    "ZepChatMessageHistory": "langchain_community.chat_message_histories.zep",
+    "ZepCloudChatMessageHistory": "langchain_community.chat_message_histories.zep_cloud",  # noqa: E501
+    "KafkaChatMessageHistory": "langchain_community.chat_message_histories.kafka",
+}
+
+
+def __getattr__(name: str) -> Any:
+    if name in _module_lookup:
+        module = importlib.import_module(_module_lookup[name])
+        return getattr(module, name)
+    raise AttributeError(f"module {__name__} has no attribute {name}")

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_message_histories/astradb.py

@@ -0,0 +1,162 @@
+"""Astra DB - based chat message history, based on astrapy."""
+
+from __future__ import annotations
+
+import json
+import time
+from typing import TYPE_CHECKING, List, Optional, Sequence
+
+from langchain_community.utilities.astradb import (
+    SetupMode,
+    _AstraDBCollectionEnvironment,
+)
+
+if TYPE_CHECKING:
+    from astrapy.db import AstraDB, AsyncAstraDB
+
+from langchain_core._api.deprecation import deprecated
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.messages import (
+    BaseMessage,
+    message_to_dict,
+    messages_from_dict,
+)
+
+DEFAULT_COLLECTION_NAME = "langchain_message_store"
+
+
+@deprecated(
+    since="0.0.25",
+    removal="1.0",
+    alternative_import="langchain_astradb.AstraDBChatMessageHistory",
+)
+class AstraDBChatMessageHistory(BaseChatMessageHistory):
+    def __init__(
+        self,
+        *,
+        session_id: str,
+        collection_name: str = DEFAULT_COLLECTION_NAME,
+        token: Optional[str] = None,
+        api_endpoint: Optional[str] = None,
+        astra_db_client: Optional[AstraDB] = None,
+        async_astra_db_client: Optional[AsyncAstraDB] = None,
+        namespace: Optional[str] = None,
+        setup_mode: SetupMode = SetupMode.SYNC,
+        pre_delete_collection: bool = False,
+    ) -> None:
+        """Chat message history that stores history in Astra DB.
+
+        Args:
+            session_id: arbitrary key that is used to store the messages
+                of a single chat session.
+            collection_name: name of the Astra DB collection to create/use.
+            token: API token for Astra DB usage.
+            api_endpoint: full URL to the API endpoint,
+                such as "https://<DB-ID>-us-east1.apps.astra.datastax.com".
+            astra_db_client: *alternative to token+api_endpoint*,
+                you can pass an already-created 'astrapy.db.AstraDB' instance.
+            async_astra_db_client: *alternative to token+api_endpoint*,
+                you can pass an already-created 'astrapy.db.AsyncAstraDB' instance.
+            namespace: namespace (aka keyspace) where the
+                collection is created. Defaults to the database's "default namespace".
+            setup_mode: mode used to create the Astra DB collection (SYNC, ASYNC or
+                OFF).
+            pre_delete_collection: whether to delete the collection
+                before creating it. If False and the collection already exists,
+                the collection will be used as is.
+        """
+        self.astra_env = _AstraDBCollectionEnvironment(
+            collection_name=collection_name,
+            token=token,
+            api_endpoint=api_endpoint,
+            astra_db_client=astra_db_client,
+            async_astra_db_client=async_astra_db_client,
+            namespace=namespace,
+            setup_mode=setup_mode,
+            pre_delete_collection=pre_delete_collection,
+        )
+
+        self.collection = self.astra_env.collection
+        self.async_collection = self.astra_env.async_collection
+
+        self.session_id = session_id
+        self.collection_name = collection_name
+
+    @property
+    def messages(self) -> List[BaseMessage]:
+        """Retrieve all session messages from DB"""
+        self.astra_env.ensure_db_setup()
+        message_blobs = [
+            doc["body_blob"]
+            for doc in sorted(
+                self.collection.paginated_find(
+                    filter={
+                        "session_id": self.session_id,
+                    },
+                    projection={
+                        "timestamp": 1,
+                        "body_blob": 1,
+                    },
+                ),
+                key=lambda _doc: _doc["timestamp"],
+            )
+        ]
+        items = [json.loads(message_blob) for message_blob in message_blobs]
+        messages = messages_from_dict(items)
+        return messages
+
+    @messages.setter
+    def messages(self, messages: List[BaseMessage]) -> None:
+        raise NotImplementedError("Use add_messages instead")
+
+    async def aget_messages(self) -> List[BaseMessage]:
+        await self.astra_env.aensure_db_setup()
+        docs = self.async_collection.paginated_find(
+            filter={
+                "session_id": self.session_id,
+            },
+            projection={
+                "timestamp": 1,
+                "body_blob": 1,
+            },
+        )
+        sorted_docs = sorted(
+            [doc async for doc in docs],
+            key=lambda _doc: _doc["timestamp"],
+        )
+        message_blobs = [doc["body_blob"] for doc in sorted_docs]
+        items = [json.loads(message_blob) for message_blob in message_blobs]
+        messages = messages_from_dict(items)
+        return messages
+
+    def add_messages(self, messages: Sequence[BaseMessage]) -> None:
+        self.astra_env.ensure_db_setup()
+        docs = [
+            {
+                "timestamp": time.time(),
+                "session_id": self.session_id,
+                "body_blob": json.dumps(message_to_dict(message)),
+            }
+            for message in messages
+        ]
+        self.collection.chunked_insert_many(docs)
+
+    async def aadd_messages(self, messages: Sequence[BaseMessage]) -> None:
+        await self.astra_env.aensure_db_setup()
+        docs = [
+            {
+                "timestamp": time.time(),
+                "session_id": self.session_id,
+                "body_blob": json.dumps(message_to_dict(message)),
+            }
+            for message in messages
+        ]
+        await self.async_collection.chunked_insert_many(docs)
+
+    def clear(self) -> None:
+        self.astra_env.ensure_db_setup()
+        self.collection.delete_many(filter={"session_id": self.session_id})
+
+    async def aclear(self) -> None:
+        await self.astra_env.aensure_db_setup()
+        await self.async_collection.delete_many(filter={"session_id": self.session_id})

micromamba_root/envs/pytorch_env/Lib/site-packages/langchain_community/chat_message_histories/cassandra.py

@@ -0,0 +1,130 @@
+"""Cassandra-based chat message history, based on cassIO."""
+
+from __future__ import annotations
+
+import json
+import uuid
+from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Sequence
+
+from langchain_community.utilities.cassandra import SetupMode
+
+if TYPE_CHECKING:
+    from cassandra.cluster import Session
+    from cassio.table.table_types import RowType
+
+from langchain_core.chat_history import BaseChatMessageHistory
+from langchain_core.messages import (
+    BaseMessage,
+    message_to_dict,
+    messages_from_dict,
+)
+
+DEFAULT_TABLE_NAME = "message_store"
+DEFAULT_TTL_SECONDS = None
+
+
+def _rows_to_messages(rows: Iterable[RowType]) -> List[BaseMessage]:
+    message_blobs = [row["body_blob"] for row in rows][::-1]
+    items = [json.loads(message_blob) for message_blob in message_blobs]
+    messages = messages_from_dict(items)
+    return messages
+
+
+class CassandraChatMessageHistory(BaseChatMessageHistory):
+    """Chat message history that is backed by Cassandra."""
+
+    def __init__(
+        self,
+        session_id: str,
+        session: Optional[Session] = None,
+        keyspace: Optional[str] = None,
+        table_name: str = DEFAULT_TABLE_NAME,
+        ttl_seconds: Optional[int] = DEFAULT_TTL_SECONDS,
+        *,
+        setup_mode: SetupMode = SetupMode.SYNC,
+    ) -> None:
+        """
+        Initialize a new instance of CassandraChatMessageHistory.
+
+        Args:
+            session_id: arbitrary key that is used to store the messages
+                of a single chat session.
+            session: Cassandra driver session.
+                If not provided, it is resolved from cassio.
+            keyspace: Cassandra key space. If not provided, it is resolved from cassio.
+            table_name: name of the table to use.
+            ttl_seconds: time-to-live (seconds) for automatic expiration
+                of stored entries. None (default) for no expiration.
+            setup_mode: mode used to create the Cassandra table (SYNC, ASYNC or OFF).
+        """
+        try:
+            from cassio.table import ClusteredCassandraTable
+        except (ImportError, ModuleNotFoundError):
+            raise ImportError(
+                "Could not import cassio python package. "
+                "Please install it with `pip install cassio`."
+            )
+        self.session_id = session_id
+        self.ttl_seconds = ttl_seconds
+        kwargs: Dict[str, Any] = {}
+        if setup_mode == SetupMode.ASYNC:
+            kwargs["async_setup"] = True
+        self.table = ClusteredCassandraTable(
+            session=session,
+            keyspace=keyspace,
+            table=table_name,
+            ttl_seconds=ttl_seconds,
+            primary_key_type=["TEXT", "TIMEUUID"],
+            ordering_in_partition="DESC",
+            skip_provisioning=setup_mode == SetupMode.OFF,
+            **kwargs,
+        )
+
+    @property
+    def messages(self) -> List[BaseMessage]:  # type: ignore[override]
+        """Retrieve all session messages from DB"""
+        # The latest are returned, in chronological order
+        rows = self.table.get_partition(
+            partition_id=self.session_id,
+        )
+        return _rows_to_messages(rows)
+
+    async def aget_messages(self) -> List[BaseMessage]:
+        """Retrieve all session messages from DB"""
+        # The latest are returned, in chronological order
+        rows = await self.table.aget_partition(
+            partition_id=self.session_id,
+        )
+        return _rows_to_messages(rows)
+
+    def add_message(self, message: BaseMessage) -> None:
+        """Write a message to the table
+
+        Args:
+            message: A message to write.
+        """
+        this_row_id = uuid.uuid4()
+        self.table.put(
+            partition_id=self.session_id,
+            row_id=this_row_id,
+            body_blob=json.dumps(message_to_dict(message)),
+            ttl_seconds=self.ttl_seconds,
+        )
+
+    async def aadd_messages(self, messages: Sequence[BaseMessage]) -> None:
+        for message in messages:
+            this_row_id = uuid.uuid4()
+            await self.table.aput(
+                partition_id=self.session_id,
+                row_id=this_row_id,
+                body_blob=json.dumps(message_to_dict(message)),
+                ttl_seconds=self.ttl_seconds,
+            )
+
+    def clear(self) -> None:
+        """Clear session memory from DB"""
+        self.table.delete_partition(self.session_id)
+
+    async def aclear(self) -> None:
+        """Clear session memory from DB"""
+        await self.table.adelete_partition(self.session_id)