langchain-core 0.4.0.dev0__py3-none-any.whl → 1.0.0__py3-none-any.whl

langchain_core/stores.py

@@ -11,11 +11,11 @@ from collections.abc import AsyncIterator, Iterator, Sequence
 from typing import (
     Any,
     Generic,
-    Optional,
     TypeVar,
-    Union,
 )
 
+from typing_extensions import override
+
 from langchain_core.exceptions import LangChainException
 from langchain_core.runnables import run_in_executor
 
@@ -47,55 +47,53 @@ class BaseStore(ABC, Generic[K, V]):
     which will usually be more efficient by saving on round trips to the store.
 
     Examples:
-
-        .. code-block:: python
-
-            from langchain.storage import BaseStore
-
-            class MyInMemoryStore(BaseStore[str, int]):
-
-                def __init__(self):
-                    self.store = {}
-
-                def mget(self, keys):
-                    return [self.store.get(key) for key in keys]
-
-                def mset(self, key_value_pairs):
-                    for key, value in key_value_pairs:
-                        self.store[key] = value
-
-                def mdelete(self, keys):
-                    for key in keys:
-                        if key in self.store:
-                            del self.store[key]
-
-                def yield_keys(self, prefix=None):
-                    if prefix is None:
-                        yield from self.store.keys()
-                    else:
-                        for key in self.store.keys():
-                            if key.startswith(prefix):
-                                yield key
-
+        ```python
+        from langchain.storage import BaseStore
+
+
+        class MyInMemoryStore(BaseStore[str, int]):
+            def __init__(self) -> None:
+                self.store: dict[str, int] = {}
+
+            def mget(self, keys: Sequence[str]) -> list[int | None]:
+                return [self.store.get(key) for key in keys]
+
+            def mset(self, key_value_pairs: Sequence[tuple[str, int]]) -> None:
+                for key, value in key_value_pairs:
+                    self.store[key] = value
+
+            def mdelete(self, keys: Sequence[str]) -> None:
+                for key in keys:
+                    if key in self.store:
+                        del self.store[key]
+
+            def yield_keys(self, prefix: str | None = None) -> Iterator[str]:
+                if prefix is None:
+                    yield from self.store.keys()
+                else:
+                    for key in self.store.keys():
+                        if key.startswith(prefix):
+                            yield key
+        ```
     """
 
     @abstractmethod
-    def mget(self, keys: Sequence[K]) -> list[Optional[V]]:
+    def mget(self, keys: Sequence[K]) -> list[V | None]:
         """Get the values associated with the given keys.
 
         Args:
-            keys (Sequence[K]): A sequence of keys.
+            keys: A sequence of keys.
 
         Returns:
             A sequence of optional values associated with the keys.
             If a key is not found, the corresponding value will be None.
         """
 
-    async def amget(self, keys: Sequence[K]) -> list[Optional[V]]:
+    async def amget(self, keys: Sequence[K]) -> list[V | None]:
         """Async get the values associated with the given keys.
 
         Args:
-            keys (Sequence[K]): A sequence of keys.
+            keys: A sequence of keys.
 
         Returns:
             A sequence of optional values associated with the keys.
@@ -108,14 +106,14 @@ class BaseStore(ABC, Generic[K, V]):
         """Set the values for the given keys.
 
         Args:
-            key_value_pairs (Sequence[tuple[K, V]]): A sequence of key-value pairs.
+            key_value_pairs: A sequence of key-value pairs.
         """
 
     async def amset(self, key_value_pairs: Sequence[tuple[K, V]]) -> None:
         """Async set the values for the given keys.
 
         Args:
-            key_value_pairs (Sequence[tuple[K, V]]): A sequence of key-value pairs.
+            key_value_pairs: A sequence of key-value pairs.
         """
         return await run_in_executor(None, self.mset, key_value_pairs)
 
@@ -124,42 +122,40 @@ class BaseStore(ABC, Generic[K, V]):
         """Delete the given keys and their associated values.
 
         Args:
-            keys (Sequence[K]): A sequence of keys to delete.
+            keys: A sequence of keys to delete.
         """
 
     async def amdelete(self, keys: Sequence[K]) -> None:
         """Async delete the given keys and their associated values.
 
         Args:
-            keys (Sequence[K]): A sequence of keys to delete.
+            keys: A sequence of keys to delete.
         """
         return await run_in_executor(None, self.mdelete, keys)
 
     @abstractmethod
-    def yield_keys(
-        self, *, prefix: Optional[str] = None
-    ) -> Union[Iterator[K], Iterator[str]]:
+    def yield_keys(self, *, prefix: str | None = None) -> Iterator[K] | Iterator[str]:
         """Get an iterator over keys that match the given prefix.
 
         Args:
-            prefix (str): The prefix to match.
+            prefix: The prefix to match.
 
         Yields:
-            Iterator[K | str]: An iterator over keys that match the given prefix.
+            An iterator over keys that match the given prefix.
             This method is allowed to return an iterator over either K or str
             depending on what makes more sense for the given store.
         """
 
     async def ayield_keys(
-        self, *, prefix: Optional[str] = None
-    ) -> Union[AsyncIterator[K], AsyncIterator[str]]:
+        self, *, prefix: str | None = None
+    ) -> AsyncIterator[K] | AsyncIterator[str]:
         """Async get an iterator over keys that match the given prefix.
 
         Args:
-            prefix (str): The prefix to match.
+            prefix: The prefix to match.
 
         Yields:
-            Iterator[K | str]: An iterator over keys that match the given prefix.
+            The keys that match the given prefix.
             This method is allowed to return an iterator over either K or str
             depending on what makes more sense for the given store.
         """
@@ -182,79 +178,41 @@ class InMemoryBaseStore(BaseStore[str, V], Generic[V]):
         """Initialize an empty store."""
         self.store: dict[str, V] = {}
 
-    def mget(self, keys: Sequence[str]) -> list[Optional[V]]:
-        """Get the values associated with the given keys.
-
-        Args:
-            keys (Sequence[str]): A sequence of keys.
-
-        Returns:
-            A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
-        """
+    @override
+    def mget(self, keys: Sequence[str]) -> list[V | None]:
         return [self.store.get(key) for key in keys]
 
-    async def amget(self, keys: Sequence[str]) -> list[Optional[V]]:
-        """Async get the values associated with the given keys.
-
-        Args:
-            keys (Sequence[str]): A sequence of keys.
-
-        Returns:
-            A sequence of optional values associated with the keys.
-            If a key is not found, the corresponding value will be None.
-        """
+    @override
+    async def amget(self, keys: Sequence[str]) -> list[V | None]:
         return self.mget(keys)
 
+    @override
     def mset(self, key_value_pairs: Sequence[tuple[str, V]]) -> None:
-        """Set the values for the given keys.
-
-        Args:
-            key_value_pairs (Sequence[tuple[str, V]]): A sequence of key-value pairs.
-
-        Returns:
-            None
-        """
         for key, value in key_value_pairs:
             self.store[key] = value
 
+    @override
     async def amset(self, key_value_pairs: Sequence[tuple[str, V]]) -> None:
-        """Async set the values for the given keys.
-
-        Args:
-            key_value_pairs (Sequence[tuple[str, V]]): A sequence of key-value pairs.
-
-        Returns:
-            None
-        """
         return self.mset(key_value_pairs)
 
+    @override
     def mdelete(self, keys: Sequence[str]) -> None:
-        """Delete the given keys and their associated values.
-
-        Args:
-            keys (Sequence[str]): A sequence of keys to delete.
-        """
         for key in keys:
             if key in self.store:
                 del self.store[key]
 
+    @override
     async def amdelete(self, keys: Sequence[str]) -> None:
-        """Async delete the given keys and their associated values.
-
-        Args:
-            keys (Sequence[str]): A sequence of keys to delete.
-        """
         self.mdelete(keys)
 
-    def yield_keys(self, prefix: Optional[str] = None) -> Iterator[str]:
+    def yield_keys(self, prefix: str | None = None) -> Iterator[str]:
         """Get an iterator over keys that match the given prefix.
 
         Args:
-            prefix (str, optional): The prefix to match. Defaults to None.
+            prefix: The prefix to match.
 
         Yields:
-            Iterator[str]: An iterator over keys that match the given prefix.
+            The keys that match the given prefix.
         """
         if prefix is None:
             yield from self.store.keys()
@@ -263,14 +221,14 @@ class InMemoryBaseStore(BaseStore[str, V], Generic[V]):
                 if key.startswith(prefix):
                     yield key
 
-    async def ayield_keys(self, prefix: Optional[str] = None) -> AsyncIterator[str]:
+    async def ayield_keys(self, prefix: str | None = None) -> AsyncIterator[str]:
         """Async get an async iterator over keys that match the given prefix.
 
         Args:
-            prefix (str, optional): The prefix to match. Defaults to None.
+            prefix: The prefix to match.
 
         Yields:
-            AsyncIterator[str]: An async iterator over keys that match the given prefix.
+            The keys that match the given prefix.
         """
         if prefix is None:
             for key in self.store:
@@ -289,21 +247,19 @@ class InMemoryStore(InMemoryBaseStore[Any]):
             the key-value pairs.
 
     Examples:
-
-        .. code-block:: python
-
-            from langchain.storage import InMemoryStore
-
-            store = InMemoryStore()
-            store.mset([('key1', 'value1'), ('key2', 'value2')])
-            store.mget(['key1', 'key2'])
-            # ['value1', 'value2']
-            store.mdelete(['key1'])
-            list(store.yield_keys())
-            # ['key2']
-            list(store.yield_keys(prefix='k'))
-            # ['key2']
-
+        ```python
+        from langchain.storage import InMemoryStore
+
+        store = InMemoryStore()
+        store.mset([("key1", "value1"), ("key2", "value2")])
+        store.mget(["key1", "key2"])
+        # ['value1', 'value2']
+        store.mdelete(["key1"])
+        list(store.yield_keys())
+        # ['key2']
+        list(store.yield_keys(prefix="k"))
+        # ['key2']
+        ```
     """
 
 
@@ -315,21 +271,19 @@ class InMemoryByteStore(InMemoryBaseStore[bytes]):
             the key-value pairs.
 
     Examples:
-
-        .. code-block:: python
-
-            from langchain.storage import InMemoryByteStore
-
-            store = InMemoryByteStore()
-            store.mset([('key1', b'value1'), ('key2', b'value2')])
-            store.mget(['key1', 'key2'])
-            # [b'value1', b'value2']
-            store.mdelete(['key1'])
-            list(store.yield_keys())
-            # ['key2']
-            list(store.yield_keys(prefix='k'))
-            # ['key2']
-
+        ```python
+        from langchain.storage import InMemoryByteStore
+
+        store = InMemoryByteStore()
+        store.mset([("key1", b"value1"), ("key2", b"value2")])
+        store.mget(["key1", "key2"])
+        # [b'value1', b'value2']
+        store.mdelete(["key1"])
+        list(store.yield_keys())
+        # ['key2']
+        list(store.yield_keys(prefix="k"))
+        # ['key2']
+        ```
     """
 
 

langchain_core/structured_query.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from enum import Enum
-from typing import TYPE_CHECKING, Any, Optional, Union
+from typing import TYPE_CHECKING, Any
 
 from pydantic import BaseModel
 
@@ -15,12 +15,12 @@ if TYPE_CHECKING:
 class Visitor(ABC):
     """Defines interface for IR translation using a visitor pattern."""
 
-    allowed_comparators: Optional[Sequence[Comparator]] = None
+    allowed_comparators: Sequence[Comparator] | None = None
     """Allowed comparators for the visitor."""
-    allowed_operators: Optional[Sequence[Operator]] = None
+    allowed_operators: Sequence[Operator] | None = None
     """Allowed operators for the visitor."""
 
-    def _validate_func(self, func: Union[Operator, Comparator]) -> None:
+    def _validate_func(self, func: Operator | Comparator) -> None:
         if (
             isinstance(func, Operator)
             and self.allowed_operators is not None
@@ -143,7 +143,7 @@ class Comparison(FilterDirective):
             value: The value to compare to.
         """
         # super exists from BaseModel
-        super().__init__(  # type: ignore[call-arg]
+        super().__init__(
             comparator=comparator, attribute=attribute, value=value, **kwargs
         )
 
@@ -166,9 +166,7 @@ class Operation(FilterDirective):
             arguments: The arguments to the operator.
         """
         # super exists from BaseModel
-        super().__init__(  # type: ignore[call-arg]
-            operator=operator, arguments=arguments, **kwargs
-        )
+        super().__init__(operator=operator, arguments=arguments, **kwargs)
 
 
 class StructuredQuery(Expr):
@@ -176,16 +174,16 @@ class StructuredQuery(Expr):
 
     query: str
     """Query string."""
-    filter: Optional[FilterDirective]
+    filter: FilterDirective | None
     """Filtering expression."""
-    limit: Optional[int]
+    limit: int | None
     """Limit on the number of results."""
 
     def __init__(
         self,
         query: str,
-        filter: Optional[FilterDirective],  # noqa: A002
-        limit: Optional[int] = None,
+        filter: FilterDirective | None,  # noqa: A002
+        limit: int | None = None,
         **kwargs: Any,
     ) -> None:
         """Create a StructuredQuery.
@@ -196,6 +194,4 @@ class StructuredQuery(Expr):
             limit: The limit on the number of results.
         """
         # super exists from BaseModel
-        super().__init__(  # type: ignore[call-arg]
-            query=query, filter=filter, limit=limit, **kwargs
-        )
+        super().__init__(query=query, filter=filter, limit=limit, **kwargs)

langchain_core/sys_info.py

@@ -1,12 +1,15 @@
-"""**sys_info** prints information about the system and langchain packages for debugging purposes."""  # noqa: E501
+"""Print information about the system and langchain packages for debugging purposes."""
 
+import pkgutil
+import platform
+import re
+import sys
 from collections.abc import Sequence
+from importlib import metadata, util
 
 
 def _get_sub_deps(packages: Sequence[str]) -> list[str]:
     """Get any specified sub-dependencies."""
-    from importlib import metadata
-
     sub_deps = set()
     underscored_packages = {pkg.replace("-", "_") for pkg in packages}
 
@@ -20,9 +23,12 @@ def _get_sub_deps(packages: Sequence[str]) -> list[str]:
             continue
 
         for req in required:
-            cleaned_req = req.split(" ")[0]
-            if cleaned_req.replace("-", "_") not in underscored_packages:
-                sub_deps.add(cleaned_req)
+            # Extract package name (e.g., "httpx<1,>=0.23.0" -> "httpx")
+            match = re.match(r"^([a-zA-Z0-9_.-]+)", req)
+            if match:
+                pkg_name = match.group(1)
+                if pkg_name.replace("-", "_") not in underscored_packages:
+                    sub_deps.add(pkg_name)
 
     return sorted(sub_deps, key=lambda x: x.lower())
 
@@ -33,11 +39,6 @@ def print_sys_info(*, additional_pkgs: Sequence[str] = ()) -> None:
     Args:
         additional_pkgs: Additional packages to include in the output.
     """
-    import pkgutil
-    import platform
-    import sys
-    from importlib import metadata, util
-
     # Packages that do not start with "langchain" prefix.
     other_langchain_packages = [
         "langserve",
@@ -74,17 +75,17 @@ def print_sys_info(*, additional_pkgs: Sequence[str] = ()) -> None:
         "OS Version": platform.version(),
         "Python Version": sys.version,
     }
-    print()  # noqa: T201
-    print("System Information")  # noqa: T201
-    print("------------------")  # noqa: T201
-    print("> OS: ", system_info["OS"])  # noqa: T201
-    print("> OS Version: ", system_info["OS Version"])  # noqa: T201
-    print("> Python Version: ", system_info["Python Version"])  # noqa: T201
+    print()
+    print("System Information")
+    print("------------------")
+    print("> OS: ", system_info["OS"])
+    print("> OS Version: ", system_info["OS Version"])
+    print("> Python Version: ", system_info["Python Version"])
 
     # Print out only langchain packages
-    print()  # noqa: T201
-    print("Package Information")  # noqa: T201
-    print("-------------------")  # noqa: T201
+    print()
+    print("Package Information")
+    print("-------------------")
 
     not_installed = []
 
@@ -105,30 +106,28 @@ def print_sys_info(*, additional_pkgs: Sequence[str] = ()) -> None:
 
         # Print package with version
         if package_version is not None:
-            print(f"> {pkg}: {package_version}")  # noqa: T201
-        else:
-            print(f"> {pkg}: Installed. No version info available.")  # noqa: T201
+            print(f"> {pkg}: {package_version}")
 
     if not_installed:
-        print()  # noqa: T201
-        print("Optional packages not installed")  # noqa: T201
-        print("-------------------------------")  # noqa: T201
+        print()
+        print("Optional packages not installed")
+        print("-------------------------------")
         for pkg in not_installed:
-            print(f"> {pkg}")  # noqa: T201
+            print(f"> {pkg}")
 
     sub_dependencies = _get_sub_deps(all_packages)
 
     if sub_dependencies:
-        print()  # noqa: T201
-        print("Other Dependencies")  # noqa: T201
-        print("------------------")  # noqa: T201
+        print()
+        print("Other Dependencies")
+        print("------------------")
 
         for dep in sub_dependencies:
             try:
                 dep_version = metadata.version(dep)
-                print(f"> {dep}: {dep_version}")  # noqa: T201
+                print(f"> {dep}: {dep_version}")
             except Exception:
-                print(f"> {dep}: Installed. No version info available.")  # noqa: T201
+                print(f"> {dep}: Installed. No version info available.")
 
 
 if __name__ == "__main__":

langchain_core/tools/__init__.py

@@ -2,20 +2,7 @@
 
 Each tool has a **description**. Agent uses the description to choose the right
 tool for the job.
-
-**Class hierarchy:**
-
-.. code-block::
-
-    RunnableSerializable --> BaseTool --> <name>Tool  # Examples: AIPluginTool, BaseGraphQLTool
-                                          <name>      # Examples: BraveSearch, HumanInputRun
-
-**Main helpers:**
-
-.. code-block::
-
-    CallbackManagerForToolRun, AsyncCallbackManagerForToolRun
-"""  # noqa: E501
+"""
 
 from __future__ import annotations