langchain-core 0.3.0.dev0__tar.gz → 0.3.0.dev1__tar.gz

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.1
 Name: langchain-core
-Version: 0.3.0.dev0
+Version: 0.3.0.dev1
 Summary: Building applications with LLMs through composability
 Home-page: https://github.com/langchain-ai/langchain
 License: MIT
-Requires-Python: >=3.8.1,<4.0
+Requires-Python: >=3.9,<4.0
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9

langchain_core-0.3.0.dev1/langchain_core/__init__.py

@@ -0,0 +1,25 @@
+"""``langchain-core`` defines the base abstractions for the LangChain ecosystem.
+
+The interfaces for core components like chat models, LLMs, vector stores, retrievers,
+and more are defined here. The universal invocation protocol (Runnables) along with
+a syntax for combining components (LangChain Expression Language) are also defined here.
+
+No third-party integrations are defined here. The dependencies are kept purposefully
+very lightweight.
+"""
+
+from importlib import metadata
+
+from langchain_core._api import (
+    surface_langchain_beta_warnings,
+    surface_langchain_deprecation_warnings,
+)
+
+try:
+    __version__ = metadata.version(__package__)
+except metadata.PackageNotFoundError:
+    # Case where package metadata is not available.
+    __version__ = ""
+
+surface_langchain_deprecation_warnings()
+surface_langchain_beta_warnings()

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/_api/beta_decorator.py

@@ -270,7 +270,7 @@ def warn_beta(
             message += f" {addendum}"
 
     warning = LangChainBetaWarning(message)
-    warnings.warn(warning, category=LangChainBetaWarning, stacklevel=2)
+    warnings.warn(warning, category=LangChainBetaWarning, stacklevel=4)
 
 
 def surface_langchain_beta_warnings() -> None:

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/_api/deprecation.py

@@ -14,7 +14,17 @@ import contextlib
 import functools
 import inspect
 import warnings
-from typing import Any, Callable, Generator, Type, TypeVar, Union, cast
+from typing import (
+    Any,
+    Callable,
+    Generator,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
+
+from typing_extensions import ParamSpec
 
 from langchain_core._api.internal import is_caller_internal
 
@@ -30,7 +40,8 @@ class LangChainPendingDeprecationWarning(PendingDeprecationWarning):
 # PUBLIC API
 
 
-T = TypeVar("T", bound=Union[Type, Callable[..., Any]])
+# Last Any should be FieldInfoV1 but this leads to circular imports
+T = TypeVar("T", bound=Union[Type, Callable[..., Any], Any])
 
 
 def _validate_deprecation_params(
@@ -133,6 +144,7 @@ def deprecated(
         _package: str = package,
     ) -> T:
         """Implementation of the decorator returned by `deprecated`."""
+        from langchain_core.utils.pydantic import FieldInfoV1
 
         def emit_warning() -> None:
             """Emit the warning."""
@@ -207,50 +219,73 @@ def deprecated(
                 )
                 return cast(T, obj)
 
+        elif isinstance(obj, FieldInfoV1):
+            wrapped = None
+            if not _obj_type:
+                _obj_type = "attribute"
+            if not _name:
+                raise ValueError(f"Field {obj} must have a name to be deprecated.")
+            old_doc = obj.description
+
+            def finalize(wrapper: Callable[..., Any], new_doc: str) -> T:
+                return cast(
+                    T,
+                    FieldInfoV1(
+                        default=obj.default,
+                        default_factory=obj.default_factory,
+                        description=new_doc,
+                        alias=obj.alias,
+                        exclude=obj.exclude,
+                    ),
+                )
+
         elif isinstance(obj, property):
             if not _obj_type:
                 _obj_type = "attribute"
             wrapped = None
-            _name = _name or obj.fget.__qualname__
+            _name = _name or cast(Union[Type, Callable], obj.fget).__qualname__
             old_doc = obj.__doc__
 
             class _deprecated_property(property):
                 """A deprecated property."""
 
-                def __init__(self, fget=None, fset=None, fdel=None, doc=None):
+                def __init__(self, fget=None, fset=None, fdel=None, doc=None):  # type: ignore[no-untyped-def]
                     super().__init__(fget, fset, fdel, doc)
                     self.__orig_fget = fget
                     self.__orig_fset = fset
                     self.__orig_fdel = fdel
 
-                def __get__(self, instance, owner=None):
+                def __get__(self, instance, owner=None):  # type: ignore[no-untyped-def]
                     if instance is not None or owner is not None:
                         emit_warning()
                     return self.fget(instance)
 
-                def __set__(self, instance, value):
+                def __set__(self, instance, value):  # type: ignore[no-untyped-def]
                     if instance is not None:
                         emit_warning()
                     return self.fset(instance, value)
 
-                def __delete__(self, instance):
+                def __delete__(self, instance):  # type: ignore[no-untyped-def]
                     if instance is not None:
                         emit_warning()
                     return self.fdel(instance)
 
-                def __set_name__(self, owner, set_name):
+                def __set_name__(self, owner, set_name):  # type: ignore[no-untyped-def]
                     nonlocal _name
                     if _name == "<lambda>":
                         _name = set_name
 
-            def finalize(wrapper: Callable[..., Any], new_doc: str) -> Any:
+            def finalize(wrapper: Callable[..., Any], new_doc: str) -> T:
                 """Finalize the property."""
-                return _deprecated_property(
-                    fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc
+                return cast(
+                    T,
+                    _deprecated_property(
+                        fget=obj.fget, fset=obj.fset, fdel=obj.fdel, doc=new_doc
+                    ),
                 )
 
         else:
-            _name = _name or obj.__qualname__
+            _name = _name or cast(Union[Type, Callable], obj).__qualname__
             if not _obj_type:
                 # edge case: when a function is within another function
                 # within a test, this will call it a "method" not a "function"
@@ -409,7 +444,7 @@ def warn_deprecated(
         LangChainPendingDeprecationWarning if pending else LangChainDeprecationWarning
     )
     warning = warning_cls(message)
-    warnings.warn(warning, category=LangChainDeprecationWarning, stacklevel=2)
+    warnings.warn(warning, category=LangChainDeprecationWarning, stacklevel=4)
 
 
 def surface_langchain_deprecation_warnings() -> None:
@@ -423,3 +458,51 @@ def surface_langchain_deprecation_warnings() -> None:
         "default",
         category=LangChainDeprecationWarning,
     )
+
+
+_P = ParamSpec("_P")
+_R = TypeVar("_R")
+
+
+def rename_parameter(
+    *,
+    since: str,
+    removal: str,
+    old: str,
+    new: str,
+) -> Callable[[Callable[_P, _R]], Callable[_P, _R]]:
+    """Decorator indicating that parameter *old* of *func* is renamed to *new*.
+
+    The actual implementation of *func* should use *new*, not *old*.  If *old*
+    is passed to *func*, a DeprecationWarning is emitted, and its value is
+    used, even if *new* is also passed by keyword.
+
+    Example:
+
+        .. code-block:: python
+
+            @_api.rename_parameter("3.1", "bad_name", "good_name")
+            def func(good_name): ...
+    """
+
+    def decorator(f: Callable[_P, _R]) -> Callable[_P, _R]:
+        @functools.wraps(f)
+        def wrapper(*args: _P.args, **kwargs: _P.kwargs) -> _R:
+            if new in kwargs and old in kwargs:
+                raise TypeError(
+                    f"{f.__name__}() got multiple values for argument {new!r}"
+                )
+            if old in kwargs:
+                warn_deprecated(
+                    since,
+                    removal=removal,
+                    message=f"The parameter `{old}` of `{f.__name__}` was "
+                    f"deprecated in {since} and will be removed "
+                    f"in {removal} Use `{new}` instead.",
+                )
+                kwargs[new] = kwargs.pop(old)
+            return f(*args, **kwargs)
+
+        return wrapper
+
+    return decorator

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/callbacks/base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, Any, Dict, List, Optional, Sequence, TypeVar, Union
 from uuid import UUID
 
@@ -13,6 +14,8 @@ if TYPE_CHECKING:
     from langchain_core.messages import BaseMessage
     from langchain_core.outputs import ChatGenerationChunk, GenerationChunk, LLMResult
 
+_LOGGER = logging.getLogger(__name__)
+
 
 class RetrieverManagerMixin:
     """Mixin for Retriever callbacks."""
@@ -911,15 +914,67 @@ class BaseCallbackManager(CallbackManagerMixin):
     def copy(self: T) -> T:
         """Copy the callback manager."""
         return self.__class__(
-            handlers=self.handlers,
-            inheritable_handlers=self.inheritable_handlers,
+            handlers=self.handlers.copy(),
+            inheritable_handlers=self.inheritable_handlers.copy(),
             parent_run_id=self.parent_run_id,
-            tags=self.tags,
-            inheritable_tags=self.inheritable_tags,
-            metadata=self.metadata,
-            inheritable_metadata=self.inheritable_metadata,
+            tags=self.tags.copy(),
+            inheritable_tags=self.inheritable_tags.copy(),
+            metadata=self.metadata.copy(),
+            inheritable_metadata=self.inheritable_metadata.copy(),
+        )
+
+    def merge(self: T, other: BaseCallbackManager) -> T:
+        """Merge the callback manager with another callback manager.
+
+        May be overwritten in subclasses. Primarily used internally
+        within merge_configs.
+
+        Returns:
+            BaseCallbackManager: The merged callback manager of the same type
+                as the current object.
+
+        Example: Merging two callback managers.
+
+            .. code-block:: python
+
+                from langchain_core.callbacks.manager import CallbackManager, trace_as_chain_group
+                from langchain_core.callbacks.stdout import StdOutCallbackHandler
+
+                manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
+                with trace_as_chain_group("My Group Name", tags=["tag1"]) as group_manager:
+                    merged_manager = group_manager.merge(manager)
+                    print(merged_manager.handlers)
+                    # [
+                    #    <langchain_core.callbacks.stdout.StdOutCallbackHandler object at ...>,
+                    #    <langchain_core.callbacks.streaming_stdout.StreamingStdOutCallbackHandler object at ...>,
+                    # ]
+
+                    print(merged_manager.tags)
+                    #    ['tag2', 'tag1']
+
+        """  # noqa: E501
+        manager = self.__class__(
+            parent_run_id=self.parent_run_id or other.parent_run_id,
+            handlers=[],
+            inheritable_handlers=[],
+            tags=list(set(self.tags + other.tags)),
+            inheritable_tags=list(set(self.inheritable_tags + other.inheritable_tags)),
+            metadata={
+                **self.metadata,
+                **other.metadata,
+            },
         )
 
+        handlers = self.handlers + other.handlers
+        inheritable_handlers = self.inheritable_handlers + other.inheritable_handlers
+
+        for handler in handlers:
+            manager.add_handler(handler)
+
+        for handler in inheritable_handlers:
+            manager.add_handler(handler, inherit=True)
+        return manager
+
     @property
     def is_async(self) -> bool:
         """Whether the callback manager is async."""

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/callbacks/manager.py

@@ -1612,16 +1612,75 @@ class CallbackManagerForChainGroup(CallbackManager):
     def copy(self) -> CallbackManagerForChainGroup:
         """Copy the callback manager."""
         return self.__class__(
-            handlers=self.handlers,
-            inheritable_handlers=self.inheritable_handlers,
+            handlers=self.handlers.copy(),
+            inheritable_handlers=self.inheritable_handlers.copy(),
             parent_run_id=self.parent_run_id,
-            tags=self.tags,
-            inheritable_tags=self.inheritable_tags,
-            metadata=self.metadata,
-            inheritable_metadata=self.inheritable_metadata,
+            tags=self.tags.copy(),
+            inheritable_tags=self.inheritable_tags.copy(),
+            metadata=self.metadata.copy(),
+            inheritable_metadata=self.inheritable_metadata.copy(),
+            parent_run_manager=self.parent_run_manager,
+        )
+
+    def merge(
+        self: CallbackManagerForChainGroup, other: BaseCallbackManager
+    ) -> CallbackManagerForChainGroup:
+        """Merge the group callback manager with another callback manager.
+
+        Overwrites the merge method in the base class to ensure that the
+        parent run manager is preserved. Keeps the parent_run_manager
+        from the current object.
+
+        Returns:
+            CallbackManagerForChainGroup: A copy of the current object with the
+                handlers, tags, and other attributes merged from the other object.
+
+        Example: Merging two callback managers.
+
+            .. code-block:: python
+
+                from langchain_core.callbacks.manager import CallbackManager, trace_as_chain_group
+                from langchain_core.callbacks.stdout import StdOutCallbackHandler
+
+                manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
+                with trace_as_chain_group("My Group Name", tags=["tag1"]) as group_manager:
+                    merged_manager = group_manager.merge(manager)
+                    print(type(merged_manager))
+                    # <class 'langchain_core.callbacks.manager.CallbackManagerForChainGroup'>
+
+                    print(merged_manager.handlers)
+                    # [
+                    #    <langchain_core.callbacks.stdout.LangChainTracer object at ...>,
+                    #    <langchain_core.callbacks.streaming_stdout.StdOutCallbackHandler object at ...>,
+                    # ]
+
+                    print(merged_manager.tags)
+                    #    ['tag2', 'tag1']
+
+        """  # noqa: E501
+        manager = self.__class__(
+            parent_run_id=self.parent_run_id or other.parent_run_id,
+            handlers=[],
+            inheritable_handlers=[],
+            tags=list(set(self.tags + other.tags)),
+            inheritable_tags=list(set(self.inheritable_tags + other.inheritable_tags)),
+            metadata={
+                **self.metadata,
+                **other.metadata,
+            },
             parent_run_manager=self.parent_run_manager,
         )
 
+        handlers = self.handlers + other.handlers
+        inheritable_handlers = self.inheritable_handlers + other.inheritable_handlers
+
+        for handler in handlers:
+            manager.add_handler(handler)
+
+        for handler in inheritable_handlers:
+            manager.add_handler(handler, inherit=True)
+        return manager
+
     def on_chain_end(self, outputs: Union[Dict[str, Any], Any], **kwargs: Any) -> None:
         """Run when traced chain group ends.
 
@@ -2040,16 +2099,75 @@ class AsyncCallbackManagerForChainGroup(AsyncCallbackManager):
     def copy(self) -> AsyncCallbackManagerForChainGroup:
         """Copy the async callback manager."""
         return self.__class__(
-            handlers=self.handlers,
-            inheritable_handlers=self.inheritable_handlers,
+            handlers=self.handlers.copy(),
+            inheritable_handlers=self.inheritable_handlers.copy(),
             parent_run_id=self.parent_run_id,
-            tags=self.tags,
-            inheritable_tags=self.inheritable_tags,
-            metadata=self.metadata,
-            inheritable_metadata=self.inheritable_metadata,
+            tags=self.tags.copy(),
+            inheritable_tags=self.inheritable_tags.copy(),
+            metadata=self.metadata.copy(),
+            inheritable_metadata=self.inheritable_metadata.copy(),
+            parent_run_manager=self.parent_run_manager,
+        )
+
+    def merge(
+        self: AsyncCallbackManagerForChainGroup, other: BaseCallbackManager
+    ) -> AsyncCallbackManagerForChainGroup:
+        """Merge the group callback manager with another callback manager.
+
+        Overwrites the merge method in the base class to ensure that the
+        parent run manager is preserved. Keeps the parent_run_manager
+        from the current object.
+
+        Returns:
+            AsyncCallbackManagerForChainGroup: A copy of the current AsyncCallbackManagerForChainGroup
+                with the handlers, tags, etc. of the other callback manager merged in.
+
+        Example: Merging two callback managers.
+
+            .. code-block:: python
+
+                from langchain_core.callbacks.manager import CallbackManager, atrace_as_chain_group
+                from langchain_core.callbacks.stdout import StdOutCallbackHandler
+
+                manager = CallbackManager(handlers=[StdOutCallbackHandler()], tags=["tag2"])
+                async with atrace_as_chain_group("My Group Name", tags=["tag1"]) as group_manager:
+                    merged_manager = group_manager.merge(manager)
+                    print(type(merged_manager))
+                    # <class 'langchain_core.callbacks.manager.AsyncCallbackManagerForChainGroup'>
+
+                    print(merged_manager.handlers)
+                    # [
+                    #    <langchain_core.callbacks.stdout.LangChainTracer object at ...>,
+                    #    <langchain_core.callbacks.streaming_stdout.StdOutCallbackHandler object at ...>,
+                    # ]
+
+                    print(merged_manager.tags)
+                    #    ['tag2', 'tag1']
+
+        """  # noqa: E501
+        manager = self.__class__(
+            parent_run_id=self.parent_run_id or other.parent_run_id,
+            handlers=[],
+            inheritable_handlers=[],
+            tags=list(set(self.tags + other.tags)),
+            inheritable_tags=list(set(self.inheritable_tags + other.inheritable_tags)),
+            metadata={
+                **self.metadata,
+                **other.metadata,
+            },
             parent_run_manager=self.parent_run_manager,
         )
 
+        handlers = self.handlers + other.handlers
+        inheritable_handlers = self.inheritable_handlers + other.inheritable_handlers
+
+        for handler in handlers:
+            manager.add_handler(handler)
+
+        for handler in inheritable_handlers:
+            manager.add_handler(handler, inherit=True)
+        return manager
+
     async def on_chain_end(
         self, outputs: Union[Dict[str, Any], Any], **kwargs: Any
     ) -> None:

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/document_loaders/__init__.py

@@ -1,5 +1,6 @@
 from langchain_core.document_loaders.base import BaseBlobParser, BaseLoader
 from langchain_core.document_loaders.blob_loaders import Blob, BlobLoader, PathLike
+from langchain_core.document_loaders.langsmith import LangSmithLoader
 
 __all__ = [
     "BaseBlobParser",
@@ -7,4 +8,5 @@ __all__ = [
     "Blob",
     "BlobLoader",
     "PathLike",
+    "LangSmithLoader",
 ]

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/document_loaders/base.py

@@ -14,7 +14,7 @@ if TYPE_CHECKING:
 from langchain_core.documents.base import Blob
 
 
-class BaseLoader(ABC):
+class BaseLoader(ABC):  # noqa: B024
     """Interface for Document Loader.
 
     Implementations should implement the lazy-loading method using generators

langchain_core-0.3.0.dev1/langchain_core/document_loaders/langsmith.py

@@ -0,0 +1,128 @@
+import datetime
+import json
+import uuid
+from typing import Any, Callable, Iterator, Optional, Sequence, Union
+
+from langsmith import Client as LangSmithClient
+
+from langchain_core.document_loaders.base import BaseLoader
+from langchain_core.documents import Document
+
+
+class LangSmithLoader(BaseLoader):
+    """Load LangSmith Dataset examples as Documents.
+
+    Loads the example inputs as the Document page content and places the entire example
+    into the Document metadata. This allows you to easily create few-shot example
+    retrievers from the loaded documents.
+
+    .. dropdown:: Lazy load
+
+        .. code-block:: python
+
+            from langchain_core.document_loaders import LangSmithLoader
+
+            loader = LangSmithLoader(dataset_id="...", limit=100)
+            docs = []
+            for doc in loader.lazy_load():
+                docs.append(doc)
+
+        .. code-block:: pycon
+
+            # -> [Document("...", metadata={"inputs": {...}, "outputs": {...}, ...}), ...]
+
+    .. versionadded:: 0.2.34
+    """  # noqa: E501
+
+    def __init__(
+        self,
+        *,
+        dataset_id: Optional[Union[uuid.UUID, str]] = None,
+        dataset_name: Optional[str] = None,
+        example_ids: Optional[Sequence[Union[uuid.UUID, str]]] = None,
+        as_of: Optional[Union[datetime.datetime, str]] = None,
+        splits: Optional[Sequence[str]] = None,
+        inline_s3_urls: bool = True,
+        offset: int = 0,
+        limit: Optional[int] = None,
+        metadata: Optional[dict] = None,
+        filter: Optional[str] = None,
+        content_key: str = "",
+        format_content: Optional[Callable[..., str]] = None,
+        client: Optional[LangSmithClient] = None,
+        **client_kwargs: Any,
+    ) -> None:
+        """
+        Args:
+            dataset_id: The ID of the dataset to filter by. Defaults to None.
+            dataset_name: The name of the dataset to filter by. Defaults to None.
+            content_key: The inputs key to set as Document page content. ``"."`` characters
+                are interpreted as nested keys. E.g. ``content_key="first.second"`` will
+                result in
+                ``Document(page_content=format_content(example.inputs["first"]["second"]))``
+            format_content: Function for converting the content extracted from the example
+                inputs into a string. Defaults to JSON-encoding the contents.
+            example_ids: The IDs of the examples to filter by. Defaults to None.
+            as_of: The dataset version tag OR
+                timestamp to retrieve the examples as of.
+                Response examples will only be those that were present at the time
+                of the tagged (or timestamped) version.
+            splits: A list of dataset splits, which are
+                divisions of your dataset such as 'train', 'test', or 'validation'.
+                Returns examples only from the specified splits.
+            inline_s3_urls: Whether to inline S3 URLs. Defaults to True.
+            offset: The offset to start from. Defaults to 0.
+            limit: The maximum number of examples to return.
+            filter: A structured filter string to apply to the examples.
+            client: LangSmith Client. If not provided will be initialized from below args.
+            client_kwargs: Keyword args to pass to LangSmith client init. Should only be
+                specified if ``client`` isn't.
+        """  # noqa: E501
+        if client and client_kwargs:
+            raise ValueError
+        self._client = client or LangSmithClient(**client_kwargs)
+        self.content_key = list(content_key.split(".")) if content_key else []
+        self.format_content = format_content or _stringify
+        self.dataset_id = dataset_id
+        self.dataset_name = dataset_name
+        self.example_ids = example_ids
+        self.as_of = as_of
+        self.splits = splits
+        self.inline_s3_urls = inline_s3_urls
+        self.offset = offset
+        self.limit = limit
+        self.metadata = metadata
+        self.filter = filter
+
+    def lazy_load(self) -> Iterator[Document]:
+        for example in self._client.list_examples(
+            dataset_id=self.dataset_id,
+            dataset_name=self.dataset_name,
+            example_ids=self.example_ids,
+            as_of=self.as_of,
+            splits=self.splits,
+            inline_s3_urls=self.inline_s3_urls,
+            offset=self.offset,
+            limit=self.limit,
+            metadata=self.metadata,
+            filter=self.filter,
+        ):
+            content: Any = example.inputs
+            for key in self.content_key:
+                content = content[key]
+            content_str = self.format_content(content)
+            metadata = example.dict()
+            # Stringify datetime and UUID types.
+            for k in ("dataset_id", "created_at", "modified_at", "source_run_id", "id"):
+                metadata[k] = str(metadata[k]) if metadata[k] else metadata[k]
+            yield Document(content_str, metadata=metadata)
+
+
+def _stringify(x: Union[str, dict]) -> str:
+    if isinstance(x, str):
+        return x
+    else:
+        try:
+            return json.dumps(x, indent=2)
+        except Exception:
+            return str(x)

{langchain_core-0.3.0.dev0 → langchain_core-0.3.0.dev1}/langchain_core/documents/base.py

@@ -141,7 +141,7 @@ class Blob(BaseMedia):
     def as_string(self) -> str:
         """Read data as a string."""
         if self.data is None and self.path:
-            with open(str(self.path), "r", encoding=self.encoding) as f:
+            with open(str(self.path), encoding=self.encoding) as f:
                 return f.read()
         elif isinstance(self.data, bytes):
             return self.data.decode(self.encoding)