The agent engineering platform.
Python agentsaiai-agentsanthropicchatgptdeepagentsenterpriseframeworkgeminigenerative-ailangchainlanggraphllmmultiagentopen-sourceopenaipydanticpythonragtypescript
core: Cleanup Pydantic models and handle deprecation warnings (#30799)
Christophe Bornet7e046ea848d1
diff --git a/libs/core/langchain_core/_api/deprecation.py b/libs/core/langchain_core/_api/deprecation.pyindex fcbfc58b38..355d9d2274 100644--- a/libs/core/langchain_core/_api/deprecation.py+++ b/libs/core/langchain_core/_api/deprecation.py@@ -23,6 +23,8 @@ from typing import (cast,)+from pydantic.fields import FieldInfo+from pydantic.v1.fields import FieldInfo as FieldInfoV1from typing_extensions import ParamSpecfrom langchain_core._api.internal import is_caller_internal@@ -152,10 +154,6 @@ def deprecated(_package: str = package,) -> T:"""Implementation of the decorator returned by `deprecated`."""- from langchain_core.utils.pydantic import ( # type: ignore[attr-defined]- FieldInfoV1,- FieldInfoV2,- )def emit_warning() -> None:"""Emit the warning."""@@ -249,7 +247,7 @@ def deprecated(),)- elif isinstance(obj, FieldInfoV2):+ elif isinstance(obj, FieldInfo):wrapped = Noneif not _obj_type:_obj_type = "attribute"@@ -261,7 +259,7 @@ def deprecated(def finalize(wrapper: Callable[..., Any], new_doc: str) -> T: # noqa: ARG001return cast("T",- FieldInfoV2(+ FieldInfo(default=obj.default,default_factory=obj.default_factory,description=new_doc,diff --git a/libs/core/langchain_core/output_parsers/base.py b/libs/core/langchain_core/output_parsers/base.pyindex a14a10829f..5554fbc5bc 100644--- a/libs/core/langchain_core/output_parsers/base.py+++ b/libs/core/langchain_core/output_parsers/base.py@@ -326,7 +326,7 @@ class BaseOutputParser(def dict(self, **kwargs: Any) -> dict:"""Return dictionary representation of output parser."""- output_parser_dict = super().dict(**kwargs)+ output_parser_dict = super().model_dump(**kwargs)with contextlib.suppress(NotImplementedError):output_parser_dict["_type"] = self._typereturn output_parser_dictdiff --git a/libs/core/langchain_core/output_parsers/json.py b/libs/core/langchain_core/output_parsers/json.pyindex 021c7a03bd..8d8e4d5276 100644--- a/libs/core/langchain_core/output_parsers/json.py+++ b/libs/core/langchain_core/output_parsers/json.py@@ -9,6 +9,7 @@ from typing import Annotated, Any, Optional, TypeVar, Unionimport jsonpatch # type: ignore[import-untyped]import pydanticfrom pydantic import SkipValidation+from pydantic.v1 import BaseModelfrom typing_extensions import overridefrom langchain_core.exceptions import OutputParserException@@ -20,16 +21,9 @@ from langchain_core.utils.json import (parse_json_markdown,parse_partial_json,)-from langchain_core.utils.pydantic import IS_PYDANTIC_V1-if IS_PYDANTIC_V1:- PydanticBaseModel = pydantic.BaseModel--else:- from pydantic.v1 import BaseModel-- # Union type needs to be last assignment to PydanticBaseModel to make mypy happy.- PydanticBaseModel = Union[BaseModel, pydantic.BaseModel] # type: ignore[assignment,misc]+# Union type needs to be last assignment to PydanticBaseModel to make mypy happy.+PydanticBaseModel = Union[BaseModel, pydantic.BaseModel]TBaseModel = TypeVar("TBaseModel", bound=PydanticBaseModel)diff --git a/libs/core/langchain_core/output_parsers/openai_functions.py b/libs/core/langchain_core/output_parsers/openai_functions.pyindex c656fc5cbb..a9e1f5f58f 100644--- a/libs/core/langchain_core/output_parsers/openai_functions.py+++ b/libs/core/langchain_core/output_parsers/openai_functions.py@@ -7,6 +7,7 @@ from typing import Any, Optional, Unionimport jsonpatch # type: ignore[import-untyped]from pydantic import BaseModel, model_validator+from pydantic.v1 import BaseModel as BaseModelV1from typing_extensions import overridefrom langchain_core.exceptions import OutputParserException@@ -275,10 +276,13 @@ class PydanticOutputFunctionsParser(OutputFunctionsParser):pydantic_schema = self.pydantic_schema[fn_name]else:pydantic_schema = self.pydantic_schema- if hasattr(pydantic_schema, "model_validate_json"):+ if issubclass(pydantic_schema, BaseModel):pydantic_args = pydantic_schema.model_validate_json(_args)- else:+ elif issubclass(pydantic_schema, BaseModelV1):pydantic_args = pydantic_schema.parse_raw(_args)+ else:+ msg = f"Unsupported pydantic schema: {pydantic_schema}"+ raise ValueError(msg)return pydantic_argsdiff --git a/libs/core/langchain_core/output_parsers/pydantic.py b/libs/core/langchain_core/output_parsers/pydantic.pyindex 194cc3a2d3..b543df5576 100644--- a/libs/core/langchain_core/output_parsers/pydantic.py+++ b/libs/core/langchain_core/output_parsers/pydantic.py@@ -11,7 +11,6 @@ from langchain_core.exceptions import OutputParserExceptionfrom langchain_core.output_parsers import JsonOutputParserfrom langchain_core.outputs import Generationfrom langchain_core.utils.pydantic import (- IS_PYDANTIC_V2,PydanticBaseModel,TBaseModel,)@@ -24,22 +23,16 @@ class PydanticOutputParser(JsonOutputParser, Generic[TBaseModel]):"""The pydantic model to parse."""def _parse_obj(self, obj: dict) -> TBaseModel:- if IS_PYDANTIC_V2:- try:- if issubclass(self.pydantic_object, pydantic.BaseModel):- return self.pydantic_object.model_validate(obj)- if issubclass(self.pydantic_object, pydantic.v1.BaseModel):- return self.pydantic_object.parse_obj(obj)- msg = f"Unsupported model version for PydanticOutputParser: \- {self.pydantic_object.__class__}"- raise OutputParserException(msg)- except (pydantic.ValidationError, pydantic.v1.ValidationError) as e:- raise self._parser_exception(e, obj) from e- else: # pydantic v1- try:+ try:+ if issubclass(self.pydantic_object, pydantic.BaseModel):+ return self.pydantic_object.model_validate(obj)+ if issubclass(self.pydantic_object, pydantic.v1.BaseModel):return self.pydantic_object.parse_obj(obj)- except pydantic.ValidationError as e:- raise self._parser_exception(e, obj) from e+ msg = f"Unsupported model version for PydanticOutputParser: \+ {self.pydantic_object.__class__}"+ raise OutputParserException(msg)+ except (pydantic.ValidationError, pydantic.v1.ValidationError) as e:+ raise self._parser_exception(e, obj) from edef _parser_exception(self, e: Exception, json_object: dictdiff --git a/libs/core/langchain_core/output_parsers/transform.py b/libs/core/langchain_core/output_parsers/transform.pyindex 96111f9a4c..876e66b555 100644--- a/libs/core/langchain_core/output_parsers/transform.py+++ b/libs/core/langchain_core/output_parsers/transform.py@@ -134,7 +134,7 @@ class BaseCumulativeTransformOutputParser(BaseTransformOutputParser[T]):chunk_gen = ChatGenerationChunk(message=chunk)elif isinstance(chunk, BaseMessage):chunk_gen = ChatGenerationChunk(- message=BaseMessageChunk(**chunk.dict())+ message=BaseMessageChunk(**chunk.model_dump()))else:chunk_gen = GenerationChunk(text=chunk)@@ -161,7 +161,7 @@ class BaseCumulativeTransformOutputParser(BaseTransformOutputParser[T]):chunk_gen = ChatGenerationChunk(message=chunk)elif isinstance(chunk, BaseMessage):chunk_gen = ChatGenerationChunk(- message=BaseMessageChunk(**chunk.dict())+ message=BaseMessageChunk(**chunk.model_dump()))else:chunk_gen = GenerationChunk(text=chunk)diff --git a/libs/core/langchain_core/pydantic_v1/__init__.py b/libs/core/langchain_core/pydantic_v1/__init__.pyindex e4dfbbaea1..1f7c9cb869 100644--- a/libs/core/langchain_core/pydantic_v1/__init__.py+++ b/libs/core/langchain_core/pydantic_v1/__init__.py@@ -2,24 +2,9 @@from importlib import metadata-from langchain_core._api.deprecation import warn_deprecated--# Create namespaces for pydantic v1 and v2.-# This code must stay at the top of the file before other modules may-# attempt to import pydantic since it adds pydantic_v1 and pydantic_v2 to sys.modules.-#-# This hack is done for the following reasons:-# * Langchain will attempt to remain compatible with both pydantic v1 and v2 since-# both dependencies and dependents may be stuck on either version of v1 or v2.-# * Creating namespaces for pydantic v1 and v2 should allow us to write code that-# unambiguously uses either v1 or v2 API.-# * This change is easier to roll out and roll back.--try:- from pydantic.v1 import * # noqa: F403-except ImportError:- from pydantic import * # type: ignore[assignment,no-redef] # noqa: F403+from pydantic.v1 import * # noqa: F403+from langchain_core._api.deprecation import warn_deprecatedtry:_PYDANTIC_MAJOR_VERSION: int = int(metadata.version("pydantic").split(".")[0])diff --git a/libs/core/langchain_core/pydantic_v1/dataclasses.py b/libs/core/langchain_core/pydantic_v1/dataclasses.pyindex 812660578b..cdcdb77e3a 100644--- a/libs/core/langchain_core/pydantic_v1/dataclasses.py+++ b/libs/core/langchain_core/pydantic_v1/dataclasses.py@@ -1,11 +1,8 @@"""Pydantic v1 compatibility shim."""-from langchain_core._api import warn_deprecated+from pydantic.v1.dataclasses import * # noqa: F403-try:- from pydantic.v1.dataclasses import * # noqa: F403-except ImportError:- from pydantic.dataclasses import * # type: ignore[no-redef] # noqa: F403+from langchain_core._api import warn_deprecatedwarn_deprecated("0.3.0",diff --git a/libs/core/langchain_core/pydantic_v1/main.py b/libs/core/langchain_core/pydantic_v1/main.pyindex 8849282317..005ad4ed34 100644--- a/libs/core/langchain_core/pydantic_v1/main.py+++ b/libs/core/langchain_core/pydantic_v1/main.py@@ -1,11 +1,8 @@"""Pydantic v1 compatibility shim."""-from langchain_core._api import warn_deprecated+from pydantic.v1.main import * # noqa: F403-try:- from pydantic.v1.main import * # noqa: F403-except ImportError:- from pydantic.main import * # type: ignore[assignment,no-redef] # noqa: F403+from langchain_core._api import warn_deprecatedwarn_deprecated("0.3.0",diff --git a/libs/core/langchain_core/tools/base.py b/libs/core/langchain_core/tools/base.pyindex 4ac5ceba50..1cea8876c3 100644--- a/libs/core/langchain_core/tools/base.py+++ b/libs/core/langchain_core/tools/base.py@@ -540,10 +540,13 @@ class ChildTool(BaseTool):)raise ValueError(msg)key_ = next(iter(get_fields(input_args).keys()))- if hasattr(input_args, "model_validate"):+ if issubclass(input_args, BaseModel):input_args.model_validate({key_: tool_input})- else:+ elif issubclass(input_args, BaseModelV1):input_args.parse_obj({key_: tool_input})+ else:+ msg = f"args_schema must be a Pydantic BaseModel, got {input_args}"+ raise TypeError(msg)return tool_inputif input_args is not None:if isinstance(input_args, dict):diff --git a/libs/core/langchain_core/tracers/schemas.py b/libs/core/langchain_core/tracers/schemas.pyindex e7ebad1da1..ea06cb2f9d 100644--- a/libs/core/langchain_core/tracers/schemas.py+++ b/libs/core/langchain_core/tracers/schemas.py@@ -2,8 +2,8 @@from __future__ import annotations-import datetimeimport warnings+from datetime import datetime, timezonefrom typing import Any, Optionalfrom uuid import UUID@@ -32,7 +32,7 @@ def RunTypeEnum() -> type[RunTypeEnumDep]: # noqa: N802class TracerSessionV1Base(BaseModelV1):"""Base class for TracerSessionV1."""- start_time: datetime.datetime = FieldV1(default_factory=datetime.datetime.utcnow)+ start_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))name: Optional[str] = Noneextra: Optional[dict[str, Any]] = None@@ -69,8 +69,8 @@ class BaseRun(BaseModelV1):uuid: strparent_uuid: Optional[str] = None- start_time: datetime.datetime = FieldV1(default_factory=datetime.datetime.utcnow)- end_time: datetime.datetime = FieldV1(default_factory=datetime.datetime.utcnow)+ start_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))+ end_time: datetime = FieldV1(default_factory=lambda: datetime.now(timezone.utc))extra: Optional[dict[str, Any]] = Noneexecution_order: intchild_execution_order: intdiff --git a/libs/core/langchain_core/utils/pydantic.py b/libs/core/langchain_core/utils/pydantic.pyindex cab3d4da6c..08cd7c4522 100644--- a/libs/core/langchain_core/utils/pydantic.py+++ b/libs/core/langchain_core/utils/pydantic.py@@ -21,9 +21,12 @@ from typing import (import pydanticfrom packaging import version-from pydantic import (++# root_validator is deprecated but we need it for backward compatibility of @pre_init+from pydantic import ( # type: ignore[deprecated]BaseModel,ConfigDict,+ Field,PydanticDeprecationWarning,RootModel,root_validator,@@ -38,29 +41,23 @@ from pydantic.json_schema import (JsonSchemaMode,JsonSchemaValue,)-from typing_extensions import override+from pydantic.v1 import BaseModel as BaseModelV1+from pydantic.v1 import create_model as create_model_v1+from pydantic.v1.fields import ModelField+from typing_extensions import deprecated, overrideif TYPE_CHECKING:from pydantic_core import core_schema-try:- import pydantic-- PYDANTIC_VERSION = version.parse(pydantic.__version__)-except ImportError:- PYDANTIC_VERSION = version.parse("0.0.0")+PYDANTIC_VERSION = version.parse(pydantic.__version__)+@deprecated("Use PYDANTIC_VERSION.major instead.")def get_pydantic_major_version() -> int:"""DEPRECATED - Get the major version of Pydantic.Use PYDANTIC_VERSION.major instead."""- warnings.warn(- "get_pydantic_major_version is deprecated. Use PYDANTIC_VERSION.major instead.",- DeprecationWarning,- stacklevel=2,- )return PYDANTIC_VERSION.major@@ -70,43 +67,20 @@ PYDANTIC_MINOR_VERSION = PYDANTIC_VERSION.minorIS_PYDANTIC_V1 = PYDANTIC_VERSION.major == 1IS_PYDANTIC_V2 = PYDANTIC_VERSION.major == 2-if IS_PYDANTIC_V1:- from pydantic.fields import FieldInfo as FieldInfoV1-- PydanticBaseModel = pydantic.BaseModel- TypeBaseModel = type[BaseModel]-elif IS_PYDANTIC_V2:- from pydantic.v1.fields import FieldInfo as FieldInfoV1 # type: ignore[assignment]- from pydantic.v1.fields import ModelField-- # Union type needs to be last assignment to PydanticBaseModel to make mypy happy.- PydanticBaseModel = Union[BaseModel, pydantic.BaseModel] # type: ignore[assignment,misc]- TypeBaseModel = Union[type[BaseModel], type[pydantic.BaseModel]] # type: ignore[misc]-else:- msg = f"Unsupported Pydantic version: {PYDANTIC_VERSION.major}"- raise ValueError(msg)-+PydanticBaseModel = BaseModel+TypeBaseModel = type[BaseModel]TBaseModel = TypeVar("TBaseModel", bound=PydanticBaseModel)def is_pydantic_v1_subclass(cls: type) -> bool:"""Check if the installed Pydantic version is 1.x-like."""- if IS_PYDANTIC_V1:- return True- if IS_PYDANTIC_V2:- from pydantic.v1 import BaseModel as BaseModelV1-- if issubclass(cls, BaseModelV1):- return True- return False+ return issubclass(cls, BaseModelV1)def is_pydantic_v2_subclass(cls: type) -> bool:"""Check if the installed Pydantic version is 1.x-like."""- from pydantic import BaseModel-- return IS_PYDANTIC_V2 and issubclass(cls, BaseModel)+ return issubclass(cls, BaseModel)def is_basemodel_subclass(cls: type) -> bool:@@ -114,7 +88,6 @@ def is_basemodel_subclass(cls: type) -> bool:Check if the given class is a subclass of any of the following:- * pydantic.BaseModel in Pydantic 1.x* pydantic.BaseModel in Pydantic 2.x* pydantic.v1.BaseModel in Pydantic 2.x"""@@ -122,24 +95,7 @@ def is_basemodel_subclass(cls: type) -> bool:if not inspect.isclass(cls) or isinstance(cls, GenericAlias):return False- if IS_PYDANTIC_V1:- from pydantic import BaseModel as BaseModelV1Proper-- if issubclass(cls, BaseModelV1Proper):- return True- elif IS_PYDANTIC_V2:- from pydantic import BaseModel as BaseModelV2- from pydantic.v1 import BaseModel as BaseModelV1-- if issubclass(cls, BaseModelV2):- return True-- if issubclass(cls, BaseModelV1):- return True- else:- msg = f"Unsupported Pydantic version: {PYDANTIC_VERSION.major}"- raise ValueError(msg)- return False+ return issubclass(cls, (BaseModel, BaseModelV1))def is_basemodel_instance(obj: Any) -> bool:@@ -147,28 +103,10 @@ def is_basemodel_instance(obj: Any) -> bool:Check if the given class is an instance of any of the following:- * pydantic.BaseModel in Pydantic 1.x* pydantic.BaseModel in Pydantic 2.x* pydantic.v1.BaseModel in Pydantic 2.x"""- if IS_PYDANTIC_V1:- from pydantic import BaseModel as BaseModelV1Proper-- if isinstance(obj, BaseModelV1Proper):- return True- elif IS_PYDANTIC_V2:- from pydantic import BaseModel as BaseModelV2- from pydantic.v1 import BaseModel as BaseModelV1-- if isinstance(obj, BaseModelV2):- return True-- if isinstance(obj, BaseModelV1):- return True- else:- msg = f"Unsupported Pydantic version: {PYDANTIC_VERSION.major}"- raise ValueError(msg)- return False+ return isinstance(obj, (BaseModel, BaseModelV1))# How to type hint this?@@ -184,6 +122,9 @@ def pre_init(func: Callable) -> Any:with warnings.catch_warnings():warnings.filterwarnings(action="ignore", category=PydanticDeprecationWarning)+ # Ideally we would use @model_validator(mode="before") but this would change the+ # order of the validators. See https://github.com/pydantic/pydantic/discussions/7434.+ # So we keep root_validator for backward compatibility.@root_validator(pre=True)@wraps(func)def wrapper(cls: type[BaseModel], values: dict[str, Any]) -> dict[str, Any]:@@ -244,26 +185,18 @@ class _IgnoreUnserializable(GenerateJsonSchema):def _create_subset_model_v1(name: str,- model: type[BaseModel],+ model: type[BaseModelV1],field_names: list,*,descriptions: Optional[dict] = None,fn_description: Optional[str] = None,) -> type[BaseModel]:"""Create a pydantic model with only a subset of model's fields."""- if IS_PYDANTIC_V1:- from pydantic import create_model- elif IS_PYDANTIC_V2:- from pydantic.v1 import create_model # type: ignore[no-redef]- else:- msg = f"Unsupported pydantic version: {PYDANTIC_VERSION.major}"- raise NotImplementedError(msg)-fields = {}for field_name in field_names:# Using pydantic v1 so can access __fields__ as a dict.- field = model.__fields__[field_name] # type: ignore[index]+ field = model.__fields__[field_name]t = (# this isn't perfect but should work for most functionsfield.outer_type_@@ -274,34 +207,31 @@ def _create_subset_model_v1(field.field_info.description = descriptions[field_name]fields[field_name] = (t, field.field_info)- rtn = create_model(name, **fields) # type: ignore[call-overload]+ rtn = create_model_v1(name, **fields) # type: ignore[call-overload]rtn.__doc__ = textwrap.dedent(fn_description or model.__doc__ or "")return rtndef _create_subset_model_v2(name: str,- model: type[pydantic.BaseModel],+ model: type[BaseModel],field_names: list[str],*,descriptions: Optional[dict] = None,fn_description: Optional[str] = None,-) -> type[pydantic.BaseModel]:+) -> type[BaseModel]:"""Create a pydantic model with a subset of the model fields."""- from pydantic import create_model- from pydantic.fields import FieldInfo-descriptions_ = descriptions or {}fields = {}for field_name in field_names:field = model.model_fields[field_name]description = descriptions_.get(field_name, field.description)- field_info = FieldInfo(description=description, default=field.default)+ field_info = FieldInfoV2(description=description, default=field.default)if field.metadata:field_info.metadata = field.metadatafields[field_name] = (field.annotation, field_info)- rtn = create_model( # type: ignore[call-overload]+ rtn = _create_model_base( # type: ignore[call-overload]name, **fields, __config__=ConfigDict(arbitrary_types_allowed=True))@@ -322,7 +252,7 @@ def _create_subset_model_v2(# Private functionality to create a subset model that's compatible across# different versions of pydantic.-# Handles pydantic versions 1.x and 2.x. including v1 of pydantic in 2.x.+# Handles pydantic versions 2.x. including v1 of pydantic in 2.x.# However, can't find a way to type hint this.def _create_subset_model(name: str,@@ -333,7 +263,7 @@ def _create_subset_model(fn_description: Optional[str] = None,) -> type[BaseModel]:"""Create subset model using the same pydantic version as the input model."""- if IS_PYDANTIC_V1:+ if issubclass(model, BaseModelV1):return _create_subset_model_v1(name,model,@@ -341,68 +271,43 @@ def _create_subset_model(descriptions=descriptions,fn_description=fn_description,)- if IS_PYDANTIC_V2:- from pydantic.v1 import BaseModel as BaseModelV1-- if issubclass(model, BaseModelV1):- return _create_subset_model_v1(- name,- model,- field_names,- descriptions=descriptions,- fn_description=fn_description,- )- return _create_subset_model_v2(- name,- model,- field_names,- descriptions=descriptions,- fn_description=fn_description,- )- msg = f"Unsupported pydantic version: {PYDANTIC_VERSION.major}"- raise NotImplementedError(msg)+ return _create_subset_model_v2(+ name,+ model,+ field_names,+ descriptions=descriptions,+ fn_description=fn_description,+ )++@overload+def get_fields(model: type[BaseModel]) -> dict[str, FieldInfoV2]: ...-if IS_PYDANTIC_V2:- from pydantic import BaseModel as BaseModelV2- from pydantic.v1 import BaseModel as BaseModelV1- @overload- def get_fields(model: type[BaseModelV2]) -> dict[str, FieldInfoV2]: ...+@overload+def get_fields(model: BaseModel) -> dict[str, FieldInfoV2]: ...- @overload- def get_fields(model: BaseModelV2) -> dict[str, FieldInfoV2]: ...- @overload- def get_fields(model: type[BaseModelV1]) -> dict[str, ModelField]: ...+@overload+def get_fields(model: type[BaseModelV1]) -> dict[str, ModelField]: ...- @overload- def get_fields(model: BaseModelV1) -> dict[str, ModelField]: ...- def get_fields(- model: Union[type[Union[BaseModelV2, BaseModelV1]], BaseModelV2, BaseModelV1],- ) -> Union[dict[str, FieldInfoV2], dict[str, ModelField]]:- """Get the field names of a Pydantic model."""- if hasattr(model, "model_fields"):- return model.model_fields+@overload+def get_fields(model: BaseModelV1) -> dict[str, ModelField]: ...- if hasattr(model, "__fields__"):- return model.__fields__- msg = f"Expected a Pydantic model. Got {type(model)}"- raise TypeError(msg)-elif IS_PYDANTIC_V1:- from pydantic import BaseModel as BaseModelV1_+def get_fields(+ model: Union[type[Union[BaseModel, BaseModelV1]], BaseModel, BaseModelV1],+) -> Union[dict[str, FieldInfoV2], dict[str, ModelField]]:+ """Get the field names of a Pydantic model."""+ if hasattr(model, "model_fields"):+ return model.model_fields- def get_fields( # type: ignore[no-redef]- model: Union[type[BaseModelV1_], BaseModelV1_],- ) -> dict[str, FieldInfoV1]:- """Get the field names of a Pydantic model."""- return model.__fields__ # type: ignore[return-value]+ if hasattr(model, "__fields__"):+ return model.__fields__+ msg = f"Expected a Pydantic model. Got {type(model)}"+ raise TypeError(msg)-else:- msg = f"Unsupported Pydantic version: {PYDANTIC_VERSION.major}"- raise ValueError(msg)_SchemaConfig = ConfigDict(arbitrary_types_allowed=True, frozen=True, protected_namespaces=()@@ -546,14 +451,11 @@ _RESERVED_NAMES = {key for key in dir(BaseModel) if not key.startswith("_")}def _remap_field_definitions(field_definitions: dict[str, Any]) -> dict[str, Any]:"""This remaps fields to avoid colliding with internal pydantic fields."""- from pydantic import Field- from pydantic.fields import FieldInfo-remapped = {}for key, value in field_definitions.items():if key.startswith("_") or key in _RESERVED_NAMES:# Let's add a prefix to avoid colliding with internal pydantic fields- if isinstance(value, FieldInfo):+ if isinstance(value, FieldInfoV2):msg = (f"Remapping for fields starting with '_' or fields with a name "f"matching a reserved name {_RESERVED_NAMES} is not supported if "diff --git a/libs/core/pyproject.toml b/libs/core/pyproject.tomlindex 118017b58c..921dbd6162 100644--- a/libs/core/pyproject.toml+++ b/libs/core/pyproject.toml@@ -69,7 +69,6 @@ langchain-text-splitters = { path = "../text-splitters" }strict = "True"strict_bytes = "True"enable_error_code = "deprecated"-report_deprecated_as_note = "True"# TODO: activate for 'strict' checkingdisallow_any_generics = "False"diff --git a/libs/core/tests/unit_tests/output_parsers/test_openai_tools.py b/libs/core/tests/unit_tests/output_parsers/test_openai_tools.pyindex dbb905e7f6..66aacffbd6 100644--- a/libs/core/tests/unit_tests/output_parsers/test_openai_tools.py+++ b/libs/core/tests/unit_tests/output_parsers/test_openai_tools.py@@ -16,10 +16,6 @@ from langchain_core.output_parsers.openai_tools import (PydanticToolsParser,)from langchain_core.outputs import ChatGeneration-from langchain_core.utils.pydantic import (- IS_PYDANTIC_V1,- IS_PYDANTIC_V2,-)STREAMED_MESSAGES: list = [AIMessageChunk(content=""),@@ -532,7 +528,6 @@ async def test_partial_pydantic_output_parser_async() -> None:assert actual == EXPECTED_STREAMED_PYDANTIC[email protected](not IS_PYDANTIC_V2, reason="This test is for pydantic 2")def test_parse_with_different_pydantic_2_v1() -> None:"""Test with pydantic.v1.BaseModel from pydantic 2."""import pydantic@@ -567,7 +562,6 @@ def test_parse_with_different_pydantic_2_v1() -> None:][email protected](not IS_PYDANTIC_V2, reason="This test is for pydantic 2")def test_parse_with_different_pydantic_2_proper() -> None:"""Test with pydantic.BaseModel from pydantic 2."""import pydantic@@ -602,41 +596,6 @@ def test_parse_with_different_pydantic_2_proper() -> None:][email protected](not IS_PYDANTIC_V1, reason="This test is for pydantic 1")-def test_parse_with_different_pydantic_1_proper() -> None:- """Test with pydantic.BaseModel from pydantic 1."""- import pydantic-- class Forecast(pydantic.BaseModel):- temperature: int- forecast: str-- # Can't get pydantic to work here due to the odd typing of tryig to support- # both v1 and v2 in the same codebase.- parser = PydanticToolsParser(tools=[Forecast])- message = AIMessage(- content="",- tool_calls=[- {- "id": "call_OwL7f5PE",- "name": "Forecast",- "args": {"temperature": 20, "forecast": "Sunny"},- }- ],- )-- generation = ChatGeneration(- message=message,- )-- assert parser.parse_result([generation]) == [- Forecast(- temperature=20,- forecast="Sunny",- )- ]--def test_max_tokens_error(caplog: Any) -> None:parser = PydanticToolsParser(tools=[NameCollector], first_tool_only=True)message = AIMessage(diff --git a/libs/core/tests/unit_tests/test_tools.py b/libs/core/tests/unit_tests/test_tools.pyindex f724bce74f..ec6c6a3308 100644--- a/libs/core/tests/unit_tests/test_tools.py+++ b/libs/core/tests/unit_tests/test_tools.py@@ -65,8 +65,6 @@ from langchain_core.utils.function_calling import (convert_to_openai_tool,)from langchain_core.utils.pydantic import (- IS_PYDANTIC_V1,- IS_PYDANTIC_V2,_create_subset_model,create_model_v2,)@@ -79,9 +77,11 @@ def _get_tool_call_json_schema(tool: BaseTool) -> dict:if isinstance(tool_schema, dict):return tool_schema- if hasattr(tool_schema, "model_json_schema"):+ if issubclass(tool_schema, BaseModel):return tool_schema.model_json_schema()- return tool_schema.schema()+ if issubclass(tool_schema, BaseModelV1):+ return tool_schema.schema()+ return {}def test_unnamed_decorator() -> None:@@ -1853,11 +1853,14 @@ def test_args_schema_as_pydantic(pydantic_model: Any) -> None:)input_schema = tool.get_input_schema()- input_json_schema = (- input_schema.model_json_schema()- if hasattr(input_schema, "model_json_schema")- else input_schema.schema()- )+ if issubclass(input_schema, BaseModel):+ input_json_schema = input_schema.model_json_schema()+ elif issubclass(input_schema, BaseModelV1):+ input_json_schema = input_schema.schema()+ else:+ msg = "Unknown input schema type"+ raise TypeError(msg)+assert input_json_schema == {"properties": {"a": {"title": "A", "type": "integer"},@@ -1943,12 +1946,14 @@ def test_structured_tool_with_different_pydantic_versions(pydantic_model: Any) -assert foo_tool.invoke({"a": 5, "b": "hello"}) == "foo"- args_schema = cast("BaseModel", foo_tool.args_schema)- args_json_schema = (- args_schema.model_json_schema()- if hasattr(args_schema, "model_json_schema")- else args_schema.schema()- )+ args_schema = cast("type[BaseModel]", foo_tool.args_schema)+ if issubclass(args_schema, BaseModel):+ args_json_schema = args_schema.model_json_schema()+ elif issubclass(args_schema, BaseModelV1):+ args_json_schema = args_schema.schema()+ else:+ msg = "Unknown input schema type"+ raise TypeError(msg)assert args_json_schema == {"properties": {"a": {"title": "A", "type": "integer"},@@ -1960,11 +1965,13 @@ def test_structured_tool_with_different_pydantic_versions(pydantic_model: Any) -}input_schema = foo_tool.get_input_schema()- input_json_schema = (- input_schema.model_json_schema()- if hasattr(input_schema, "model_json_schema")- else input_schema.schema()- )+ if issubclass(input_schema, BaseModel):+ input_json_schema = input_schema.model_json_schema()+ elif issubclass(input_schema, BaseModelV1):+ input_json_schema = input_schema.schema()+ else:+ msg = "Unknown input schema type"+ raise TypeError(msg)assert input_json_schema == {"properties": {"a": {"title": "A", "type": "integer"},@@ -2020,7 +2027,6 @@ def test__is_message_content_type(obj: Any, *, expected: bool) -> None:assert _is_message_content_type(obj) is expected[email protected](not IS_PYDANTIC_V2, reason="Testing pydantic v2.")@pytest.mark.parametrize("use_v1_namespace", [True, False])def test__get_all_basemodel_annotations_v2(*, use_v1_namespace: bool) -> None:A = TypeVar("A")@@ -2089,63 +2095,6 @@ def test__get_all_basemodel_annotations_v2(*, use_v1_namespace: bool) -> None:assert actual == expected[email protected](not IS_PYDANTIC_V1, reason="Testing pydantic v1.")-def test__get_all_basemodel_annotations_v1() -> None:- A = TypeVar("A")-- class ModelA(BaseModel, Generic[A], extra="allow"):- a: A-- class ModelB(ModelA[str]):- b: Annotated[ModelA[dict[str, Any]], "foo"]-- class Mixin:- def foo(self) -> str:- return "foo"-- class ModelC(Mixin, ModelB):- c: dict-- expected = {"a": str, "b": Annotated[ModelA[dict[str, Any]], "foo"], "c": dict}- actual = get_all_basemodel_annotations(ModelC)- assert actual == expected-- expected = {"a": str, "b": Annotated[ModelA[dict[str, Any]], "foo"]}- actual = get_all_basemodel_annotations(ModelB)- assert actual == expected-- expected = {"a": Any}- actual = get_all_basemodel_annotations(ModelA)- assert actual == expected-- expected = {"a": int}- actual = get_all_basemodel_annotations(ModelA[int])- assert actual == expected-- D = TypeVar("D", bound=Union[str, int])-- class ModelD(ModelC, Generic[D]):- d: Optional[D]-- expected = {- "a": str,- "b": Annotated[ModelA[dict[str, Any]], "foo"],- "c": dict,- "d": Union[str, int, None],- }- actual = get_all_basemodel_annotations(ModelD)- assert actual == expected-- expected = {- "a": str,- "b": Annotated[ModelA[dict[str, Any]], "foo"],- "c": dict,- "d": Union[int, None],- }- actual = get_all_basemodel_annotations(ModelD[int])- assert actual == expected--def test_get_all_basemodel_annotations_aliases() -> None:class CalculatorInput(BaseModel):a: int = Field(description="first number", alias="A")@@ -2226,7 +2175,6 @@ def test_create_retriever_tool() -> None:)[email protected](not IS_PYDANTIC_V2, reason="Testing pydantic v2.")def test_tool_args_schema_pydantic_v2_with_metadata() -> None:from pydantic import BaseModel as BaseModelV2from pydantic import Field as FieldV2diff --git a/libs/core/tests/unit_tests/utils/test_pydantic.py b/libs/core/tests/unit_tests/utils/test_pydantic.pyindex 88ca45ff1d..dadce0e3f7 100644--- a/libs/core/tests/unit_tests/utils/test_pydantic.py+++ b/libs/core/tests/unit_tests/utils/test_pydantic.py@@ -3,13 +3,9 @@import warningsfrom typing import Any, Optional-import pytestfrom pydantic import ConfigDictfrom langchain_core.utils.pydantic import (- IS_PYDANTIC_V1,- IS_PYDANTIC_V2,- PYDANTIC_VERSION,_create_subset_model_v2,create_model_v2,get_fields,@@ -96,50 +92,29 @@ def test_with_aliases() -> None:def test_is_basemodel_subclass() -> None:"""Test pydantic."""- if IS_PYDANTIC_V1:- from pydantic import BaseModel as BaseModelV1Proper-- assert is_basemodel_subclass(BaseModelV1Proper)- elif IS_PYDANTIC_V2:- from pydantic import BaseModel as BaseModelV2- from pydantic.v1 import BaseModel as BaseModelV1-- assert is_basemodel_subclass(BaseModelV2)+ from pydantic import BaseModel as BaseModelV2+ from pydantic.v1 import BaseModel as BaseModelV1- assert is_basemodel_subclass(BaseModelV1)- else:- msg = f"Unsupported Pydantic version: {PYDANTIC_VERSION.major}"- raise ValueError(msg)+ assert is_basemodel_subclass(BaseModelV2)+ assert is_basemodel_subclass(BaseModelV1)def test_is_basemodel_instance() -> None:"""Test pydantic."""- if IS_PYDANTIC_V1:- from pydantic import BaseModel as BaseModelV1Proper-- class FooV1(BaseModelV1Proper):- x: int-- assert is_basemodel_instance(FooV1(x=5))- elif IS_PYDANTIC_V2:- from pydantic import BaseModel as BaseModelV2- from pydantic.v1 import BaseModel as BaseModelV1+ from pydantic import BaseModel as BaseModelV2+ from pydantic.v1 import BaseModel as BaseModelV1- class Foo(BaseModelV2):- x: int+ class Foo(BaseModelV2):+ x: int- assert is_basemodel_instance(Foo(x=5))+ assert is_basemodel_instance(Foo(x=5))- class Bar(BaseModelV1):- x: int+ class Bar(BaseModelV1):+ x: int- assert is_basemodel_instance(Bar(x=5))- else:- msg = f"Unsupported Pydantic version: {PYDANTIC_VERSION.major}"- raise ValueError(msg)+ assert is_basemodel_instance(Bar(x=5))[email protected](not IS_PYDANTIC_V2, reason="Only tests Pydantic v2")def test_with_field_metadata() -> None:"""Test pydantic with field metadata."""from pydantic import BaseModel as BaseModelV2@@ -168,18 +143,6 @@ def test_with_field_metadata() -> None:}[email protected](not IS_PYDANTIC_V1, reason="Only tests Pydantic v1")-def test_fields_pydantic_v1() -> None:- from pydantic import BaseModel-- class Foo(BaseModel):- x: int-- fields = get_fields(Foo)- assert fields == {"x": Foo.model_fields["x"]}--[email protected](not IS_PYDANTIC_V2, reason="Only tests Pydantic v2")def test_fields_pydantic_v2_proper() -> None:from pydantic import BaseModel@@ -190,7 +153,6 @@ def test_fields_pydantic_v2_proper() -> None:assert fields == {"x": Foo.model_fields["x"]}[email protected](not IS_PYDANTIC_V2, reason="Only tests Pydantic v2")def test_fields_pydantic_v1_from_2() -> None:from pydantic.v1 import BaseModeldiff --git a/libs/core/tests/unit_tests/utils/test_utils.py b/libs/core/tests/unit_tests/utils/test_utils.pyindex 258b447409..b9364517ce 100644--- a/libs/core/tests/unit_tests/utils/test_utils.py+++ b/libs/core/tests/unit_tests/utils/test_utils.py@@ -16,10 +16,6 @@ from langchain_core.utils import (guard_import,)from langchain_core.utils._merge import merge_dicts-from langchain_core.utils.pydantic import (- IS_PYDANTIC_V1,- IS_PYDANTIC_V2,-)from langchain_core.utils.utils import secret_from_env@@ -214,7 +210,6 @@ def test_guard_import_failure(guard_import(module_name, pip_name=pip_name, package=package)[email protected](not IS_PYDANTIC_V2, reason="Requires pydantic 2")def test_get_pydantic_field_names_v1_in_2() -> None:from pydantic.v1 import BaseModel as PydanticV1BaseModelfrom pydantic.v1 import Field@@ -229,7 +224,6 @@ def test_get_pydantic_field_names_v1_in_2() -> None:assert result == expected[email protected](not IS_PYDANTIC_V2, reason="Requires pydantic 2")def test_get_pydantic_field_names_v2_in_2() -> None:from pydantic import BaseModel, Field@@ -243,20 +237,6 @@ def test_get_pydantic_field_names_v2_in_2() -> None:assert result == expected[email protected](not IS_PYDANTIC_V1, reason="Requires pydantic 1")-def test_get_pydantic_field_names_v1() -> None:- from pydantic import BaseModel, Field-- class PydanticModel(BaseModel):- field1: str- field2: int- alias_field: int = Field(alias="aliased_field")-- result = get_pydantic_field_names(PydanticModel)- expected = {"field1", "field2", "aliased_field", "alias_field"}- assert result == expected--def test_from_env_with_env_variable() -> None:key = "TEST_KEY"value = "test_value"