langchain-core 1.0.0a8__py3-none-any.whl → 1.0.0rc2__py3-none-any.whl

langchain_core/tracers/stdout.py

@@ -49,8 +49,7 @@ class FunctionCallbackHandler(BaseTracer):
     """Tracer that calls a function with a single str parameter."""
 
     name: str = "function_callback_handler"
-    """The name of the tracer. This is used to identify the tracer in the logs.
-    Default is "function_callback_handler"."""
+    """The name of the tracer. This is used to identify the tracer in the logs."""
 
     def __init__(self, function: Callable[[str], None], **kwargs: Any) -> None:
         """Create a FunctionCallbackHandler.

langchain_core/utils/__init__.py

@@ -1,4 +1,4 @@
-"""**Utility functions** for LangChain.
+"""Utility functions for LangChain.
 
 These functions do not depend on any other LangChain module.
 """

langchain_core/utils/aiter.py

@@ -50,7 +50,7 @@ def py_anext(
 
     Returns:
         The next value from the iterator, or the default value
-            if the iterator is exhausted.
+        if the iterator is exhausted.
 
     Raises:
         TypeError: If the iterator is not an async iterator.
@@ -107,7 +107,7 @@ async def tee_peer(
     """An individual iterator of a `tee`.
 
     This function is a generator that yields items from the shared iterator
-    ``iterator``. It buffers items until the least advanced iterator has
+    `iterator`. It buffers items until the least advanced iterator has
     yielded them as well. The buffer is shared with all other peers.
 
     Args:
@@ -153,38 +153,38 @@ async def tee_peer(
 
 
 class Tee(Generic[T]):
-    """Create ``n`` separate asynchronous iterators over ``iterable``.
+    """Create `n` separate asynchronous iterators over `iterable`.
 
-    This splits a single ``iterable`` into multiple iterators, each providing
+    This splits a single `iterable` into multiple iterators, each providing
     the same items in the same order.
     All child iterators may advance separately but share the same items
-    from ``iterable`` -- when the most advanced iterator retrieves an item,
+    from `iterable` -- when the most advanced iterator retrieves an item,
     it is buffered until the least advanced iterator has yielded it as well.
-    A ``tee`` works lazily and can handle an infinite ``iterable``, provided
+    A `tee` works lazily and can handle an infinite `iterable`, provided
     that all iterators advance.
 
-    .. code-block:: python
-
-        async def derivative(sensor_data):
-            previous, current = a.tee(sensor_data, n=2)
-            await a.anext(previous)  # advance one iterator
-            return a.map(operator.sub, previous, current)
+    ```python
+    async def derivative(sensor_data):
+        previous, current = a.tee(sensor_data, n=2)
+        await a.anext(previous)  # advance one iterator
+        return a.map(operator.sub, previous, current)
+    ```
 
     Unlike `itertools.tee`, `.tee` returns a custom type instead
     of a :py`tuple`. Like a tuple, it can be indexed, iterated and unpacked
     to get the child iterators. In addition, its `.tee.aclose` method
-    immediately closes all children, and it can be used in an ``async with`` context
+    immediately closes all children, and it can be used in an `async with` context
     for the same effect.
 
-    If ``iterable`` is an iterator and read elsewhere, ``tee`` will *not*
-    provide these items. Also, ``tee`` must internally buffer each item until the
+    If `iterable` is an iterator and read elsewhere, `tee` will *not*
+    provide these items. Also, `tee` must internally buffer each item until the
     last iterator has yielded it; if the most and least advanced iterator differ
     by most data, using a :py`list` is more efficient (but not lazy).
 
-    If the underlying iterable is concurrency safe (``anext`` may be awaited
+    If the underlying iterable is concurrency safe (`anext` may be awaited
     concurrently) the resulting iterators are concurrency safe as well. Otherwise,
     the iterators are safe if there is only ever one single "most advanced" iterator.
-    To enforce sequential use of ``anext``, provide a ``lock``
+    To enforce sequential use of `anext`, provide a `lock`
     - e.g. an :py`asyncio.Lock` instance in an :py:mod:`asyncio` application -
     and access is automatically synchronised.
 
@@ -197,13 +197,13 @@ class Tee(Generic[T]):
         *,
         lock: AbstractAsyncContextManager[Any] | None = None,
     ):
-        """Create a ``tee``.
+        """Create a `tee`.
 
         Args:
             iterable: The iterable to split.
-            n: The number of iterators to create. Defaults to 2.
+            n: The number of iterators to create.
             lock: The lock to synchronise access to the shared buffers.
-                Defaults to None.
+
         """
         self._iterator = iterable.__aiter__()  # before 3.10 aiter() doesn't exist
         self._buffers: list[deque[T]] = [deque() for _ in range(n)]
@@ -269,25 +269,25 @@ atee = Tee
 
 
 class aclosing(AbstractAsyncContextManager):  # noqa: N801
-    """Async context manager to wrap an AsyncGenerator that has a ``aclose()`` method.
+    """Async context manager to wrap an AsyncGenerator that has a `aclose()` method.
 
     Code like this:
 
-    .. code-block:: python
-
-        async with aclosing(<module>.fetch(<arguments>)) as agen:
-            <block>
+    ```python
+    async with aclosing(<module>.fetch(<arguments>)) as agen:
+        <block>
+    ```
 
     is equivalent to this:
 
-    .. code-block:: python
-
-        agen = <module>.fetch(<arguments>)
-        try:
-            <block>
-        finally:
-            await agen.aclose()
+    ```python
+    agen = <module>.fetch(<arguments>)
+    try:
+        <block>
+    finally:
+        await agen.aclose()
 
+    ```
     """
 
     def __init__(self, thing: AsyncGenerator[Any, Any] | AsyncIterator[Any]) -> None:

langchain_core/utils/env.py

@@ -10,10 +10,10 @@ def env_var_is_set(env_var: str) -> bool:
     """Check if an environment variable is set.
 
     Args:
-        env_var (str): The name of the environment variable.
+        env_var: The name of the environment variable.
 
     Returns:
-        bool: True if the environment variable is set, False otherwise.
+        `True` if the environment variable is set, `False` otherwise.
     """
     return env_var in os.environ and os.environ[env_var] not in {
         "",
@@ -38,7 +38,7 @@ def get_from_dict_or_env(
         env_key: The environment variable to look up if the key is not
             in the dictionary.
         default: The default value to return if the key is not in the dictionary
-            or the environment. Defaults to None.
+            or the environment.
 
     Returns:
         The dict value or the environment variable value.
@@ -64,10 +64,10 @@ def get_from_env(key: str, env_key: str, default: str | None = None) -> str:
         env_key: The environment variable to look up if the key is not
             in the dictionary.
         default: The default value to return if the key is not in the dictionary
-            or the environment. Defaults to None.
+            or the environment.
 
     Returns:
-        str: The value of the key.
+        The value of the key.
 
     Raises:
         ValueError: If the key is not in the dictionary and no default value is

langchain_core/utils/function_calling.py

@@ -27,7 +27,7 @@ from pydantic.v1 import create_model as create_model_v1
 from typing_extensions import TypedDict, is_typeddict
 
 import langchain_core
-from langchain_core._api import beta, deprecated
+from langchain_core._api import beta
 from langchain_core.messages import AIMessage, BaseMessage, HumanMessage, ToolMessage
 from langchain_core.utils.json_schema import dereference_refs
 from langchain_core.utils.pydantic import is_basemodel_subclass
@@ -72,11 +72,11 @@ def _rm_titles(kv: dict, prev_key: str = "") -> dict:
     except when a "title" appears within a property definition under "properties".
 
     Args:
-        kv (dict): The input JSON schema as a dictionary.
-        prev_key (str): The key from the parent dictionary, used to identify context.
+        kv: The input JSON schema as a dictionary.
+        prev_key: The key from the parent dictionary, used to identify context.
 
     Returns:
-        dict: A new dictionary with appropriate "title" fields removed.
+        A new dictionary with appropriate "title" fields removed.
     """
     new_kv = {}
 
@@ -114,7 +114,7 @@ def _convert_json_schema_to_openai_function(
             used.
         description: The description of the function. If not provided, the description
             of the schema will be used.
-        rm_titles: Whether to remove titles from the schema. Defaults to True.
+        rm_titles: Whether to remove titles from the schema.
 
     Returns:
         The function description.
@@ -148,7 +148,7 @@ def _convert_pydantic_to_openai_function(
             used.
         description: The description of the function. If not provided, the description
             of the schema will be used.
-        rm_titles: Whether to remove titles from the schema. Defaults to True.
+        rm_titles: Whether to remove titles from the schema.
 
     Raises:
         TypeError: If the model is not a Pydantic model.
@@ -168,42 +168,6 @@ def _convert_pydantic_to_openai_function(
     )
 
 
-convert_pydantic_to_openai_function = deprecated(
-    "0.1.16",
-    alternative="langchain_core.utils.function_calling.convert_to_openai_function()",
-    removal="1.0",
-)(_convert_pydantic_to_openai_function)
-
-
-@deprecated(
-    "0.1.16",
-    alternative="langchain_core.utils.function_calling.convert_to_openai_tool()",
-    removal="1.0",
-)
-def convert_pydantic_to_openai_tool(
-    model: type[BaseModel],
-    *,
-    name: str | None = None,
-    description: str | None = None,
-) -> ToolDescription:
-    """Converts a Pydantic model to a function description for the OpenAI API.
-
-    Args:
-        model: The Pydantic model to convert.
-        name: The name of the function. If not provided, the title of the schema will be
-            used.
-        description: The description of the function. If not provided, the description
-            of the schema will be used.
-
-    Returns:
-        The tool description.
-    """
-    function = _convert_pydantic_to_openai_function(
-        model, name=name, description=description
-    )
-    return {"type": "function", "function": function}
-
-
 def _get_python_function_name(function: Callable) -> str:
     """Get the name of a Python function."""
     return function.__name__
@@ -240,13 +204,6 @@ def _convert_python_function_to_openai_function(
     )
 
 
-convert_python_function_to_openai_function = deprecated(
-    "0.1.16",
-    alternative="langchain_core.utils.function_calling.convert_to_openai_function()",
-    removal="1.0",
-)(_convert_python_function_to_openai_function)
-
-
 def _convert_typed_dict_to_openai_function(typed_dict: type) -> FunctionDescription:
     visited: dict = {}
 
@@ -368,31 +325,6 @@ def _format_tool_to_openai_function(tool: BaseTool) -> FunctionDescription:
     }
 
 
-format_tool_to_openai_function = deprecated(
-    "0.1.16",
-    alternative="langchain_core.utils.function_calling.convert_to_openai_function()",
-    removal="1.0",
-)(_format_tool_to_openai_function)
-
-
-@deprecated(
-    "0.1.16",
-    alternative="langchain_core.utils.function_calling.convert_to_openai_tool()",
-    removal="1.0",
-)
-def format_tool_to_openai_tool(tool: BaseTool) -> ToolDescription:
-    """Format tool into the OpenAI function API.
-
-    Args:
-        tool: The tool to format.
-
-    Returns:
-        The tool description.
-    """
-    function = _format_tool_to_openai_function(tool)
-    return {"type": "function", "function": function}
-
-
 def convert_to_openai_function(
     function: dict[str, Any] | type | Callable | BaseTool,
     *,
@@ -402,14 +334,14 @@ def convert_to_openai_function(
 
     Args:
         function:
-            A dictionary, Pydantic BaseModel class, TypedDict class, a LangChain
-            Tool object, or a Python function. If a dictionary is passed in, it is
+            A dictionary, Pydantic `BaseModel` class, `TypedDict` class, a LangChain
+            `Tool` object, or a Python function. If a dictionary is passed in, it is
             assumed to already be a valid OpenAI function, a JSON schema with
-            top-level 'title' key specified, an Anthropic format
-            tool, or an Amazon Bedrock Converse format tool.
+            top-level `title` key specified, an Anthropic format tool, or an Amazon
+            Bedrock Converse format tool.
         strict:
-            If True, model output is guaranteed to exactly match the JSON Schema
-            provided in the function definition. If None, ``strict`` argument will not
+            If `True`, model output is guaranteed to exactly match the JSON Schema
+            provided in the function definition. If `None`, `strict` argument will not
             be included in function definition.
 
     Returns:
@@ -419,17 +351,8 @@ def convert_to_openai_function(
     Raises:
         ValueError: If function is not in a supported format.
 
-    !!! warning "Behavior changed in 0.2.29"
-        ``strict`` arg added.
-
-    !!! warning "Behavior changed in 0.3.13"
-        Support for Anthropic format tools added.
-
-    !!! warning "Behavior changed in 0.3.14"
-        Support for Amazon Bedrock Converse format tools added.
-
     !!! warning "Behavior changed in 0.3.16"
-        'description' and 'parameters' keys are now optional. Only 'name' is
+        `description` and `parameters` keys are now optional. Only `name` is
         required and guaranteed to be part of the output.
     """
     # an Anthropic format tool
@@ -527,45 +450,31 @@ def convert_to_openai_tool(
 ) -> dict[str, Any]:
     """Convert a tool-like object to an OpenAI tool schema.
 
-    OpenAI tool schema reference:
-    https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools
+    [OpenAI tool schema reference](https://platform.openai.com/docs/api-reference/chat/create#chat-create-tools)
 
     Args:
         tool:
-            Either a dictionary, a pydantic.BaseModel class, Python function, or
-            BaseTool. If a dictionary is passed in, it is
-            assumed to already be a valid OpenAI function, a JSON schema with
-            top-level 'title' key specified, an Anthropic format
-            tool, or an Amazon Bedrock Converse format tool.
+            Either a dictionary, a `pydantic.BaseModel` class, Python function, or
+            `BaseTool`. If a dictionary is passed in, it is assumed to already be a
+            valid OpenAI function, a JSON schema with top-level `title` key specified,
+            an Anthropic format tool, or an Amazon Bedrock Converse format tool.
         strict:
-            If True, model output is guaranteed to exactly match the JSON Schema
-            provided in the function definition. If None, ``strict`` argument will not
+            If `True`, model output is guaranteed to exactly match the JSON Schema
+            provided in the function definition. If `None`, `strict` argument will not
             be included in tool definition.
 
     Returns:
         A dict version of the passed in tool which is compatible with the
         OpenAI tool-calling API.
 
-    !!! warning "Behavior changed in 0.2.29"
-        ``strict`` arg added.
-
-    !!! warning "Behavior changed in 0.3.13"
-        Support for Anthropic format tools added.
-
-    !!! warning "Behavior changed in 0.3.14"
-        Support for Amazon Bedrock Converse format tools added.
-
     !!! warning "Behavior changed in 0.3.16"
-        'description' and 'parameters' keys are now optional. Only 'name' is
+        `description` and `parameters` keys are now optional. Only `name` is
         required and guaranteed to be part of the output.
 
     !!! warning "Behavior changed in 0.3.44"
         Return OpenAI Responses API-style tools unchanged. This includes
-        any dict with "type" in "file_search", "function", "computer_use_preview",
-        "web_search_preview".
-
-    !!! warning "Behavior changed in 0.3.61"
-        Added support for OpenAI's built-in code interpreter and remote MCP tools.
+        any dict with `"type"` in `"file_search"`, `"function"`,
+        `"computer_use_preview"`, `"web_search_preview"`.
 
     !!! warning "Behavior changed in 0.3.63"
         Added support for OpenAI's image generation built-in tool.
@@ -601,8 +510,8 @@ def convert_to_json_schema(
 
     Args:
         schema: The schema to convert.
-        strict: If True, model output is guaranteed to exactly match the JSON Schema
-            provided in the function definition. If None, ``strict`` argument will not
+        strict: If `True`, model output is guaranteed to exactly match the JSON Schema
+            provided in the function definition. If `None`, `strict` argument will not
             be included in function definition.
 
     Raises:
@@ -649,15 +558,15 @@ def tool_example_to_messages(
 
     The list of messages per example by default corresponds to:
 
-    1. ``HumanMessage``: contains the content from which content should be extracted.
-    2. ``AIMessage``: contains the extracted information from the model
-    3. ``ToolMessage``: contains confirmation to the model that the model requested a
-       tool correctly.
+    1. `HumanMessage`: contains the content from which content should be extracted.
+    2. `AIMessage`: contains the extracted information from the model
+    3. `ToolMessage`: contains confirmation to the model that the model requested a
+        tool correctly.
 
-    If ``ai_response`` is specified, there will be a final ``AIMessage`` with that
+    If `ai_response` is specified, there will be a final `AIMessage` with that
     response.
 
-    The ``ToolMessage`` is required because some chat models are hyper-optimized for
+    The `ToolMessage` is required because some chat models are hyper-optimized for
     agents rather than for an extraction use case.
 
     Args:
@@ -665,50 +574,46 @@ def tool_example_to_messages(
         tool_calls: Tool calls represented as Pydantic BaseModels
         tool_outputs: Tool call outputs.
             Does not need to be provided. If not provided, a placeholder value
-            will be inserted. Defaults to None.
-        ai_response: If provided, content for a final ``AIMessage``.
+            will be inserted.
+        ai_response: If provided, content for a final `AIMessage`.
 
     Returns:
         A list of messages
 
     Examples:
+        ```python
+        from typing import Optional
+        from pydantic import BaseModel, Field
+        from langchain_openai import ChatOpenAI
 
-        .. code-block:: python
 
-            from typing import Optional
-            from pydantic import BaseModel, Field
-            from langchain_openai import ChatOpenAI
-
-
-            class Person(BaseModel):
-                '''Information about a person.'''
-
-                name: Optional[str] = Field(..., description="The name of the person")
-                hair_color: Optional[str] = Field(
-                    ..., description="The color of the person's hair if known"
-                )
-                height_in_meters: Optional[str] = Field(
-                    ..., description="Height in METERS"
-                )
+        class Person(BaseModel):
+            '''Information about a person.'''
 
+            name: str | None = Field(..., description="The name of the person")
+            hair_color: str | None = Field(
+                ..., description="The color of the person's hair if known"
+            )
+            height_in_meters: str | None = Field(..., description="Height in METERS")
 
-            examples = [
-                (
-                    "The ocean is vast and blue. It's more than 20,000 feet deep.",
-                    Person(name=None, height_in_meters=None, hair_color=None),
-                ),
-                (
-                    "Fiona traveled far from France to Spain.",
-                    Person(name="Fiona", height_in_meters=None, hair_color=None),
-                ),
-            ]
 
+        examples = [
+            (
+                "The ocean is vast and blue. It's more than 20,000 feet deep.",
+                Person(name=None, height_in_meters=None, hair_color=None),
+            ),
+            (
+                "Fiona traveled far from France to Spain.",
+                Person(name="Fiona", height_in_meters=None, hair_color=None),
+            ),
+        ]
 
-            messages = []
 
-            for txt, tool_call in examples:
-                messages.extend(tool_example_to_messages(txt, [tool_call]))
+        messages = []
 
+        for txt, tool_call in examples:
+            messages.extend(tool_example_to_messages(txt, [tool_call]))
+        ```
     """
     messages: list[BaseMessage] = [HumanMessage(content=input)]
     openai_tool_calls = [
@@ -717,7 +622,7 @@ def tool_example_to_messages(
             "type": "function",
             "function": {
                 # The name of the function right now corresponds to the name
-                # of the pydantic model. This is implicit in the API right now,
+                # of the Pydantic model. This is implicit in the API right now,
                 # and will be improved over time.
                 "name": tool_call.__class__.__name__,
                 "arguments": tool_call.model_dump_json(),

langchain_core/utils/html.py

@@ -43,7 +43,7 @@ def find_all_links(
         pattern: Regex to use for extracting links from raw HTML.
 
     Returns:
-        list[str]: all links
+        all links
     """
     pattern = pattern or DEFAULT_LINK_REGEX
     return list(set(re.findall(pattern, raw_html)))
@@ -66,14 +66,14 @@ def extract_sub_links(
         url: the url of the HTML.
         base_url: the base URL to check for outside links against.
         pattern: Regex to use for extracting links from raw HTML.
-        prevent_outside: If True, ignore external links which are not children
+        prevent_outside: If `True`, ignore external links which are not children
             of the base URL.
         exclude_prefixes: Exclude any URLs that start with one of these prefixes.
-        continue_on_failure: If True, continue if parsing a specific link raises an
+        continue_on_failure: If `True`, continue if parsing a specific link raises an
             exception. Otherwise, raise the exception.
 
     Returns:
-        list[str]: sub links.
+        sub links.
     """
     base_url_to_use = base_url if base_url is not None else url
     parsed_base_url = urlparse(base_url_to_use)

langchain_core/utils/input.py

@@ -65,9 +65,9 @@ def print_text(
 
     Args:
         text: The text to print.
-        color: The color to use. Defaults to None.
-        end: The end character to use. Defaults to "".
-        file: The file to write to. Defaults to None.
+        color: The color to use.
+        end: The end character to use.
+        file: The file to write to.
     """
     text_to_print = get_colored_text(text, color) if color else text
     print(text_to_print, end=end, file=file)

langchain_core/utils/interactive_env.py

@@ -7,6 +7,6 @@ def is_interactive_env() -> bool:
     """Determine if running within IPython or Jupyter.
 
     Returns:
-        True if running in an interactive environment, False otherwise.
+        True if running in an interactive environment, `False` otherwise.
     """
     return hasattr(sys, "ps2")

langchain_core/utils/iter.py

@@ -43,7 +43,7 @@ def tee_peer(
     """An individual iterator of a `.tee`.
 
     This function is a generator that yields items from the shared iterator
-    ``iterator``. It buffers items until the least advanced iterator has
+    `iterator`. It buffers items until the least advanced iterator has
     yielded them as well. The buffer is shared with all other peers.
 
     Args:
@@ -89,38 +89,38 @@ def tee_peer(
 
 
 class Tee(Generic[T]):
-    """Create ``n`` separate asynchronous iterators over ``iterable``.
+    """Create `n` separate asynchronous iterators over `iterable`.
 
-    This splits a single ``iterable`` into multiple iterators, each providing
+    This splits a single `iterable` into multiple iterators, each providing
     the same items in the same order.
     All child iterators may advance separately but share the same items
-    from ``iterable`` -- when the most advanced iterator retrieves an item,
+    from `iterable` -- when the most advanced iterator retrieves an item,
     it is buffered until the least advanced iterator has yielded it as well.
-    A ``tee`` works lazily and can handle an infinite ``iterable``, provided
+    A `tee` works lazily and can handle an infinite `iterable`, provided
     that all iterators advance.
 
-    .. code-block:: python
-
-        async def derivative(sensor_data):
-            previous, current = a.tee(sensor_data, n=2)
-            await a.anext(previous)  # advance one iterator
-            return a.map(operator.sub, previous, current)
+    ```python
+    async def derivative(sensor_data):
+        previous, current = a.tee(sensor_data, n=2)
+        await a.anext(previous)  # advance one iterator
+        return a.map(operator.sub, previous, current)
+    ```
 
     Unlike `itertools.tee`, `.tee` returns a custom type instead
     of a :py`tuple`. Like a tuple, it can be indexed, iterated and unpacked
     to get the child iterators. In addition, its `.tee.aclose` method
-    immediately closes all children, and it can be used in an ``async with`` context
+    immediately closes all children, and it can be used in an `async with` context
     for the same effect.
 
-    If ``iterable`` is an iterator and read elsewhere, ``tee`` will *not*
-    provide these items. Also, ``tee`` must internally buffer each item until the
+    If `iterable` is an iterator and read elsewhere, `tee` will *not*
+    provide these items. Also, `tee` must internally buffer each item until the
     last iterator has yielded it; if the most and least advanced iterator differ
     by most data, using a :py`list` is more efficient (but not lazy).
 
-    If the underlying iterable is concurrency safe (``anext`` may be awaited
+    If the underlying iterable is concurrency safe (`anext` may be awaited
     concurrently) the resulting iterators are concurrency safe as well. Otherwise,
     the iterators are safe if there is only ever one single "most advanced" iterator.
-    To enforce sequential use of ``anext``, provide a ``lock``
+    To enforce sequential use of `anext`, provide a `lock`
     - e.g. an :py`asyncio.Lock` instance in an :py:mod:`asyncio` application -
     and access is automatically synchronised.
 
@@ -133,13 +133,13 @@ class Tee(Generic[T]):
         *,
         lock: AbstractContextManager[Any] | None = None,
     ):
-        """Create a ``tee``.
+        """Create a `tee`.
 
         Args:
             iterable: The iterable to split.
-            n: The number of iterators to create. Defaults to 2.
+            n: The number of iterators to create.
             lock: The lock to synchronise access to the shared buffers.
-                Defaults to None.
+
         """
         self._iterator = iter(iterable)
         self._buffers: list[deque[T]] = [deque() for _ in range(n)]
@@ -207,7 +207,7 @@ def batch_iterate(size: int | None, iterable: Iterable[T]) -> Iterator[list[T]]:
     """Utility batching function.
 
     Args:
-        size: The size of the batch. If None, returns a single batch.
+        size: The size of the batch. If `None`, returns a single batch.
         iterable: The iterable to batch.
 
     Yields: