langchain-core 1.0.0a5__py3-none-any.whl → 1.0.3__py3-none-any.whl

langchain_core/caches.py

@@ -1,31 +1,24 @@
-"""Cache classes.
+"""Optional caching layer for language models.
 
-.. warning::
-  Beta Feature!
+Distinct from provider-based [prompt caching](https://docs.langchain.com/oss/python/langchain/models#prompt-caching).
 
-**Cache** provides an optional caching layer for LLMs.
+!!! warning "Beta feature"
+    This is a beta feature. Please be wary of deploying experimental code to production
+    unless you've taken appropriate precautions.
 
-Cache is useful for two reasons:
+A cache is useful for two reasons:
 
-- It can save you money by reducing the number of API calls you make to the LLM
-  provider if you're often requesting the same completion multiple times.
-- It can speed up your application by reducing the number of API calls you make
-  to the LLM provider.
-
-Cache directly competes with Memory. See documentation for Pros and Cons.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseCache --> <name>Cache  # Examples: InMemoryCache, RedisCache, GPTCache
+1. It can save you money by reducing the number of API calls you make to the LLM
+    provider if you're often requesting the same completion multiple times.
+2. It can speed up your application by reducing the number of API calls you make to the
+    LLM provider.
 """
 
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Any, Optional
+from typing import Any
 
 from typing_extensions import override
 
@@ -40,8 +33,8 @@ class BaseCache(ABC):
 
     The cache interface consists of the following methods:
 
-    - lookup: Look up a value based on a prompt and llm_string.
-    - update: Update the cache based on a prompt and llm_string.
+    - lookup: Look up a value based on a prompt and `llm_string`.
+    - update: Update the cache based on a prompt and `llm_string`.
     - clear: Clear the cache.
 
     In addition, the cache interface provides an async version of each method.
@@ -52,44 +45,47 @@ class BaseCache(ABC):
     """
 
     @abstractmethod
-    def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
-        """Look up based on prompt and llm_string.
+    def lookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
+        """Look up based on `prompt` and `llm_string`.
 
         A cache implementation is expected to generate a key from the 2-tuple
-        of prompt and llm_string (e.g., by concatenating them with a delimiter).
+        of `prompt` and `llm_string` (e.g., by concatenating them with a delimiter).
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
+
                 This is used to capture the invocation parameters of the LLM
                 (e.g., model name, temperature, stop tokens, max tokens, etc.).
-                These invocation parameters are serialized into a string
-                representation.
+
+                These invocation parameters are serialized into a string representation.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
-            The cached value is a list of Generations (or subclasses).
+            On a cache miss, return `None`. On a cache hit, return the cached value.
+            The cached value is a list of `Generation` (or subclasses).
         """
 
     @abstractmethod
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
-        """Update cache based on prompt and llm_string.
+        """Update cache based on `prompt` and `llm_string`.
 
         The prompt and llm_string are used to generate a key for the cache.
         The key should match that of the lookup method.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
+
                 This is used to capture the invocation parameters of the LLM
                 (e.g., model name, temperature, stop tokens, max tokens, etc.).
+
                 These invocation parameters are serialized into a string
                 representation.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
 
@@ -97,46 +93,50 @@ class BaseCache(ABC):
     def clear(self, **kwargs: Any) -> None:
         """Clear cache that can take additional keyword arguments."""
 
-    async def alookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
-        """Async look up based on prompt and llm_string.
+    async def alookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
+        """Async look up based on `prompt` and `llm_string`.
 
         A cache implementation is expected to generate a key from the 2-tuple
-        of prompt and llm_string (e.g., by concatenating them with a delimiter).
+        of `prompt` and `llm_string` (e.g., by concatenating them with a delimiter).
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
+
                 This is used to capture the invocation parameters of the LLM
                 (e.g., model name, temperature, stop tokens, max tokens, etc.).
+
                 These invocation parameters are serialized into a string
                 representation.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
-            The cached value is a list of Generations (or subclasses).
+            On a cache miss, return `None`. On a cache hit, return the cached value.
+            The cached value is a list of `Generation` (or subclasses).
         """
         return await run_in_executor(None, self.lookup, prompt, llm_string)
 
     async def aupdate(
         self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE
     ) -> None:
-        """Async update cache based on prompt and llm_string.
+        """Async update cache based on `prompt` and `llm_string`.
 
         The prompt and llm_string are used to generate a key for the cache.
         The key should match that of the look up method.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
+
                 This is used to capture the invocation parameters of the LLM
                 (e.g., model name, temperature, stop tokens, max tokens, etc.).
+
                 These invocation parameters are serialized into a string
                 representation.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
         return await run_in_executor(None, self.update, prompt, llm_string, return_val)
@@ -149,17 +149,16 @@ class BaseCache(ABC):
 class InMemoryCache(BaseCache):
     """Cache that stores things in memory."""
 
-    def __init__(self, *, maxsize: Optional[int] = None) -> None:
+    def __init__(self, *, maxsize: int | None = None) -> None:
         """Initialize with empty cache.
 
         Args:
             maxsize: The maximum number of items to store in the cache.
-                If None, the cache has no maximum size.
+                If `None`, the cache has no maximum size.
                 If the cache exceeds the maximum size, the oldest items are removed.
-                Default is None.
 
         Raises:
-            ValueError: If maxsize is less than or equal to 0.
+            ValueError: If `maxsize` is less than or equal to `0`.
         """
         self._cache: dict[tuple[str, str], RETURN_VAL_TYPE] = {}
         if maxsize is not None and maxsize <= 0:
@@ -167,29 +166,29 @@ class InMemoryCache(BaseCache):
             raise ValueError(msg)
         self._maxsize = maxsize
 
-    def lookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
-        """Look up based on prompt and llm_string.
+    def lookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
+        """Look up based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
+            On a cache miss, return `None`. On a cache hit, return the cached value.
         """
         return self._cache.get((prompt, llm_string), None)
 
     def update(self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE) -> None:
-        """Update cache based on prompt and llm_string.
+        """Update cache based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
         if self._maxsize is not None and len(self._cache) == self._maxsize:
@@ -201,31 +200,31 @@ class InMemoryCache(BaseCache):
         """Clear cache."""
         self._cache = {}
 
-    async def alookup(self, prompt: str, llm_string: str) -> Optional[RETURN_VAL_TYPE]:
-        """Async look up based on prompt and llm_string.
+    async def alookup(self, prompt: str, llm_string: str) -> RETURN_VAL_TYPE | None:
+        """Async look up based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
 
         Returns:
-            On a cache miss, return None. On a cache hit, return the cached value.
+            On a cache miss, return `None`. On a cache hit, return the cached value.
         """
         return self.lookup(prompt, llm_string)
 
     async def aupdate(
         self, prompt: str, llm_string: str, return_val: RETURN_VAL_TYPE
     ) -> None:
-        """Async update cache based on prompt and llm_string.
+        """Async update cache based on `prompt` and `llm_string`.
 
         Args:
-            prompt: a string representation of the prompt.
-                In the case of a Chat model, the prompt is a non-trivial
+            prompt: A string representation of the prompt.
+                In the case of a chat model, the prompt is a non-trivial
                 serialization of the prompt into the language model.
             llm_string: A string representation of the LLM configuration.
-            return_val: The value to be cached. The value is a list of Generations
+            return_val: The value to be cached. The value is a list of `Generation`
                 (or subclasses).
         """
         self.update(prompt, llm_string, return_val)

langchain_core/callbacks/__init__.py

@@ -1,11 +1,4 @@
-"""**Callback handlers** allow listening to events in LangChain.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    BaseCallbackHandler --> <name>CallbackHandler  # Example: AimCallbackHandler
-"""
+"""**Callback handlers** allow listening to events in LangChain."""
 
 from typing import TYPE_CHECKING