fix(core): support for Python 3.14

Author: cbornet

libs/core/langchain_core/language_models/llms.py

@@ -91,13 +91,17 @@ def _before_sleep(retry_state: RetryCallState) -> None:
             if isinstance(run_manager, AsyncCallbackManagerForLLMRun):
                 coro = run_manager.on_retry(retry_state)
                 try:
-                    loop = asyncio.get_event_loop()
-                    if loop.is_running():
-                        # TODO: Fix RUF006 - this task should have a reference
-                        #  and be awaited somewhere
-                        loop.create_task(coro)  # noqa: RUF006
-                    else:
+                    try:
+                        loop = asyncio.get_event_loop()
+                    except RuntimeError:
                         asyncio.run(coro)
+                    else:
+                        if loop.is_running():
+                            # TODO: Fix RUF006 - this task should have a reference
+                            #  and be awaited somewhere
+                            loop.create_task(coro)  # noqa: RUF006
+                        else:
+                            asyncio.run(coro)
                 except Exception as e:
                     _log_error_once(f"Error in on_retry: {e}")
             else:

libs/core/langchain_core/runnables/utils.py

@@ -5,6 +5,7 @@
 import ast
 import asyncio
 import inspect
+import sys
 import textwrap
 from collections.abc import Callable, Mapping, Sequence
 from contextvars import Context
@@ -141,10 +142,10 @@ def coro_with_context(
     Returns:
         The coroutine with the context.
     """
-    if asyncio_accepts_context():
-        return asyncio.create_task(coro, context=context)  # type: ignore[arg-type,call-arg,unused-ignore]
+    if sys.version_info >= (3, 11):
+        return asyncio.create_task(coro, context=context)  # type: ignore[arg-type]
     if create_task:
-        return asyncio.create_task(coro)  # type: ignore[arg-type]
+        return asyncio.create_task(coro)  # type: ignore[arg-type, unused-ignore]
     return coro
 
 

libs/core/langchain_core/tracers/event_stream.py

@@ -128,7 +128,10 @@ def __init__(
             exclude_tags=exclude_tags,
         )
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[StreamEvent](loop)
         self.send_stream = memory_stream.get_send_stream()
         self.receive_stream = memory_stream.get_receive_stream()

libs/core/langchain_core/tracers/log_stream.py

@@ -264,7 +264,10 @@ def __init__(
         self.exclude_types = exclude_types
         self.exclude_tags = exclude_tags
 
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
         memory_stream = _MemoryStream[RunLogPatch](loop)
         self.lock = threading.Lock()
         self.send_stream = memory_stream.get_send_stream()

libs/core/tests/unit_tests/output_parsers/test_pydantic_parser.py

@@ -1,5 +1,6 @@
 """Test PydanticOutputParser."""
 
+import sys
 from enum import Enum
 from typing import Literal
 
@@ -22,15 +23,23 @@ class ForecastV2(pydantic.BaseModel):
     forecast: str
 
 
-class ForecastV1(V1BaseModel):
-    temperature: int
-    f_or_c: Literal["F", "C"]
-    forecast: str
+_FORECAST_MODELS: list[type[BaseModel | V1BaseModel]] = [ForecastV2]
+_FORECAST_MODELS_TYPES = type[ForecastV2]
+
+if sys.version_info < (3, 14):
+
+    class ForecastV1(V1BaseModel):
+        temperature: int
+        f_or_c: Literal["F", "C"]
+        forecast: str
+
+    _FORECAST_MODELS_TYPES |= type[ForecastV1]
+    _FORECAST_MODELS.append(ForecastV1)
 
 
-@pytest.mark.parametrize("pydantic_object", [ForecastV2, ForecastV1])
+@pytest.mark.parametrize("pydantic_object", _FORECAST_MODELS)
 def test_pydantic_parser_chaining(
-    pydantic_object: type[ForecastV2] | type[ForecastV1],
+    pydantic_object: _FORECAST_MODELS_TYPES,
 ) -> None:
     prompt = PromptTemplate(
         template="""{{
@@ -53,7 +62,7 @@ def test_pydantic_parser_chaining(
     assert res.forecast == "Sunny"
 
 
-@pytest.mark.parametrize("pydantic_object", [ForecastV2, ForecastV1])
+@pytest.mark.parametrize("pydantic_object", _FORECAST_MODELS)
 def test_pydantic_parser_validation(pydantic_object: TBaseModel) -> None:
     bad_prompt = PromptTemplate(
         template="""{{
@@ -75,7 +84,7 @@ def test_pydantic_parser_validation(pydantic_object: TBaseModel) -> None:
 
 
 # JSON output parser tests
-@pytest.mark.parametrize("pydantic_object", [ForecastV2, ForecastV1])
+@pytest.mark.parametrize("pydantic_object", _FORECAST_MODELS)
 def test_json_parser_chaining(
     pydantic_object: TBaseModel,
 ) -> None:

libs/core/tests/unit_tests/test_tools.py

@@ -105,14 +105,6 @@ class _MockSchema(BaseModel):
     arg3: dict | None = None
 
 
-class _MockSchemaV1(BaseModelV1):
-    """Return the arguments directly."""
-
-    arg1: int
-    arg2: bool
-    arg3: dict | None = None
-
-
 class _MockStructuredTool(BaseTool):
     name: str = "structured_api"
     args_schema: type[BaseModel] = _MockSchema
@@ -206,6 +198,20 @@ def tool_func(*, arg1: int, arg2: bool, arg3: dict | None = None) -> str:
     assert isinstance(tool_func, BaseTool)
     assert tool_func.args_schema == _MockSchema
 
+
+@pytest.mark.skipif(
+    sys.version_info >= (3, 14), reason="Pydantic v1 not supported with Python 3.14+"
+)
+def test_decorator_with_specified_schema_pydantic_v1() -> None:
+    """Test that manually specified schemata are passed through to the tool."""
+
+    class _MockSchemaV1(BaseModelV1):
+        """Return the arguments directly."""
+
+        arg1: int
+        arg2: bool
+        arg3: dict | None = None
+
     @tool(args_schema=cast("ArgsSchema", _MockSchemaV1))
     def tool_func_v1(*, arg1: int, arg2: bool, arg3: dict | None = None) -> str:
         return f"{arg1} {arg2} {arg3}"
@@ -348,6 +354,9 @@ def structured_tool(
     assert result == expected
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 14), reason="Pydantic v1 not supported with Python 3.14+"
+)
 def test_structured_tool_types_parsed_pydantic_v1() -> None:
     """Test the non-primitive types are correctly passed to structured tools."""
 
@@ -1880,7 +1889,10 @@ class FooV1Namespace(BaseModelV1):
 # behave well with either pydantic 1 proper,
 # pydantic v1 from pydantic 2,
 # or pydantic 2 proper.
-TEST_MODELS = generate_models() + generate_backwards_compatible_v1()
+TEST_MODELS = generate_models()
+
+if sys.version_info < (3, 14):
+    TEST_MODELS += generate_backwards_compatible_v1()
 
 
 @pytest.mark.parametrize("pydantic_model", TEST_MODELS)
@@ -2079,6 +2091,8 @@ def test__get_all_basemodel_annotations_v2(*, use_v1_namespace: bool) -> None:
     A = TypeVar("A")
 
     if use_v1_namespace:
+        if sys.version_info >= (3, 14):
+            pytest.skip("Pydantic v1 is not supported with Python 3.14+")
 
         class ModelA(BaseModelV1, Generic[A], extra="allow"):
             a: A

libs/core/tests/unit_tests/tracers/test_memory_stream.py

@@ -120,7 +120,7 @@ def test_send_to_closed_stream() -> None:
 
     We may want to handle this in a better way in the future.
     """
-    event_loop = asyncio.get_event_loop()
+    event_loop = asyncio.get_event_loop_policy().new_event_loop()
     channel = _MemoryStream[str](event_loop)
     writer = channel.get_send_stream()
     # send with an open even loop

libs/core/tests/unit_tests/utils/test_pydantic.py

@@ -1,8 +1,10 @@
 """Test for some custom pydantic decorators."""
 
+import sys
 import warnings
 from typing import Any
 
+import pytest
 from pydantic import BaseModel, ConfigDict, Field
 from pydantic.v1 import BaseModel as BaseModelV1
 
@@ -139,6 +141,9 @@ class Foo(BaseModel):
     assert fields == {"x": Foo.model_fields["x"]}
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 14), reason="Pydantic v1 not supported with Python 3.14+"
+)
 def test_fields_pydantic_v1_from_2() -> None:
     class Foo(BaseModelV1):
         x: int

libs/core/tests/unit_tests/utils/test_utils.py

@@ -1,5 +1,6 @@
 import os
 import re
+import sys
 from collections.abc import Callable
 from contextlib import AbstractContextManager, nullcontext
 from copy import deepcopy
@@ -214,6 +215,9 @@ def test_guard_import_failure(
         guard_import(module_name, pip_name=pip_name, package=package)
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 14), reason="Pydantic v1 not supported with Python 3.14+"
+)
 def test_get_pydantic_field_names_v1_in_2() -> None:
     class PydanticV1Model(PydanticV1BaseModel):
         field1: str