mergepythonclient 3.1.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

merge/core/pydantic_utilities.py

@@ -2,30 +2,128 @@
 
 # nopycln: file
 import datetime as dt
+import inspect
+import json
+import logging
 from collections import defaultdict
-from typing import Any, Callable, Dict, List, Mapping, Tuple, Type, TypeVar, Union, cast
+from dataclasses import asdict
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    ClassVar,
+    Dict,
+    List,
+    Mapping,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    cast,
+)
 
 import pydantic
+import typing_extensions
+from pydantic.fields import FieldInfo as _FieldInfo
+
+_logger = logging.getLogger(__name__)
+
+if TYPE_CHECKING:
+    from .http_sse._models import ServerSentEvent
 
 IS_PYDANTIC_V2 = pydantic.VERSION.startswith("2.")
 
 if IS_PYDANTIC_V2:
-    from pydantic.v1.datetime_parse import parse_date as parse_date
-    from pydantic.v1.datetime_parse import parse_datetime as parse_datetime
-    from pydantic.v1.fields import ModelField as ModelField
-    from pydantic.v1.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[attr-defined]
-    from pydantic.v1.typing import get_args as get_args
-    from pydantic.v1.typing import get_origin as get_origin
-    from pydantic.v1.typing import is_literal_type as is_literal_type
-    from pydantic.v1.typing import is_union as is_union
+    _datetime_adapter = pydantic.TypeAdapter(dt.datetime)  # type: ignore[attr-defined]
+    _date_adapter = pydantic.TypeAdapter(dt.date)  # type: ignore[attr-defined]
+
+    def parse_datetime(value: Any) -> dt.datetime:  # type: ignore[misc]
+        if isinstance(value, dt.datetime):
+            return value
+        return _datetime_adapter.validate_python(value)
+
+    def parse_date(value: Any) -> dt.date:  # type: ignore[misc]
+        if isinstance(value, dt.datetime):
+            return value.date()
+        if isinstance(value, dt.date):
+            return value
+        return _date_adapter.validate_python(value)
+
+    # Avoid importing from pydantic.v1 to maintain Python 3.14 compatibility.
+    from typing import get_args as get_args  # type: ignore[assignment]
+    from typing import get_origin as get_origin  # type: ignore[assignment]
+
+    def is_literal_type(tp: Optional[Type[Any]]) -> bool:  # type: ignore[misc]
+        return typing_extensions.get_origin(tp) is typing_extensions.Literal
+
+    def is_union(tp: Optional[Type[Any]]) -> bool:  # type: ignore[misc]
+        return tp is Union or typing_extensions.get_origin(tp) is Union  # type: ignore[comparison-overlap]
+
+    # Inline encoders_by_type to avoid importing from pydantic.v1.json
+    import re as _re
+    from collections import deque as _deque
+    from decimal import Decimal as _Decimal
+    from enum import Enum as _Enum
+    from ipaddress import (
+        IPv4Address as _IPv4Address,
+    )
+    from ipaddress import (
+        IPv4Interface as _IPv4Interface,
+    )
+    from ipaddress import (
+        IPv4Network as _IPv4Network,
+    )
+    from ipaddress import (
+        IPv6Address as _IPv6Address,
+    )
+    from ipaddress import (
+        IPv6Interface as _IPv6Interface,
+    )
+    from ipaddress import (
+        IPv6Network as _IPv6Network,
+    )
+    from pathlib import Path as _Path
+    from types import GeneratorType as _GeneratorType
+    from uuid import UUID as _UUID
+
+    from pydantic.fields import FieldInfo as ModelField  # type: ignore[no-redef, assignment]
+
+    def _decimal_encoder(dec_value: Any) -> Any:
+        if dec_value.as_tuple().exponent >= 0:
+            return int(dec_value)
+        return float(dec_value)
+
+    encoders_by_type: Dict[Type[Any], Callable[[Any], Any]] = {  # type: ignore[no-redef]
+        bytes: lambda o: o.decode(),
+        dt.date: lambda o: o.isoformat(),
+        dt.datetime: lambda o: o.isoformat(),
+        dt.time: lambda o: o.isoformat(),
+        dt.timedelta: lambda td: td.total_seconds(),
+        _Decimal: _decimal_encoder,
+        _Enum: lambda o: o.value,
+        frozenset: list,
+        _deque: list,
+        _GeneratorType: list,
+        _IPv4Address: str,
+        _IPv4Interface: str,
+        _IPv4Network: str,
+        _IPv6Address: str,
+        _IPv6Interface: str,
+        _IPv6Network: str,
+        _Path: str,
+        _re.Pattern: lambda o: o.pattern,
+        set: list,
+        _UUID: str,
+    }
 else:
     from pydantic.datetime_parse import parse_date as parse_date  # type: ignore[no-redef]
     from pydantic.datetime_parse import parse_datetime as parse_datetime  # type: ignore[no-redef]
-    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined, no-redef]
+    from pydantic.fields import ModelField as ModelField  # type: ignore[attr-defined, no-redef, assignment]
     from pydantic.json import ENCODERS_BY_TYPE as encoders_by_type  # type: ignore[no-redef]
     from pydantic.typing import get_args as get_args  # type: ignore[no-redef]
     from pydantic.typing import get_origin as get_origin  # type: ignore[no-redef]
-    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore[no-redef]
+    from pydantic.typing import is_literal_type as is_literal_type  # type: ignore[no-redef, assignment]
     from pydantic.typing import is_union as is_union  # type: ignore[no-redef]
 
 from .datetime_utils import serialize_datetime
@@ -35,6 +133,169 @@ T = TypeVar("T")
 Model = TypeVar("Model", bound=pydantic.BaseModel)
 
 
+def _get_discriminator_and_variants(type_: Type[Any]) -> Tuple[Optional[str], Optional[List[Type[Any]]]]:
+    """
+    Extract the discriminator field name and union variants from a discriminated union type.
+    Supports Annotated[Union[...], Field(discriminator=...)] patterns.
+    Returns (discriminator, variants) or (None, None) if not a discriminated union.
+    """
+    origin = typing_extensions.get_origin(type_)
+
+    if origin is typing_extensions.Annotated:
+        args = typing_extensions.get_args(type_)
+        if len(args) >= 2:
+            inner_type = args[0]
+            # Check annotations for discriminator
+            discriminator = None
+            for annotation in args[1:]:
+                if hasattr(annotation, "discriminator"):
+                    discriminator = getattr(annotation, "discriminator", None)
+                    break
+
+            if discriminator:
+                inner_origin = typing_extensions.get_origin(inner_type)
+                if inner_origin is Union:
+                    variants = list(typing_extensions.get_args(inner_type))
+                    return discriminator, variants
+    return None, None
+
+
+def _get_field_annotation(model: Type[Any], field_name: str) -> Optional[Type[Any]]:
+    """Get the type annotation of a field from a Pydantic model."""
+    if IS_PYDANTIC_V2:
+        fields = getattr(model, "model_fields", {})
+        field_info = fields.get(field_name)
+        if field_info:
+            return cast(Optional[Type[Any]], field_info.annotation)
+    else:
+        fields = getattr(model, "__fields__", {})
+        field_info = fields.get(field_name)
+        if field_info:
+            return cast(Optional[Type[Any]], field_info.outer_type_)
+    return None
+
+
+def _find_variant_by_discriminator(
+    variants: List[Type[Any]],
+    discriminator: str,
+    discriminator_value: Any,
+) -> Optional[Type[Any]]:
+    """Find the union variant that matches the discriminator value."""
+    for variant in variants:
+        if not (inspect.isclass(variant) and issubclass(variant, pydantic.BaseModel)):
+            continue
+
+        disc_annotation = _get_field_annotation(variant, discriminator)
+        if disc_annotation and is_literal_type(disc_annotation):
+            literal_args = get_args(disc_annotation)
+            if literal_args and literal_args[0] == discriminator_value:
+                return variant
+    return None
+
+
+def _is_string_type(type_: Type[Any]) -> bool:
+    """Check if a type is str or Optional[str]."""
+    if type_ is str:
+        return True
+
+    origin = typing_extensions.get_origin(type_)
+    if origin is Union:
+        args = typing_extensions.get_args(type_)
+        # Optional[str] = Union[str, None]
+        non_none_args = [a for a in args if a is not type(None)]
+        if len(non_none_args) == 1 and non_none_args[0] is str:
+            return True
+
+    return False
+
+
+def parse_sse_obj(sse: "ServerSentEvent", type_: Type[T]) -> T:
+    """
+    Parse a ServerSentEvent into the appropriate type.
+
+    Handles two scenarios based on where the discriminator field is located:
+
+    1. Data-level discrimination: The discriminator (e.g., 'type') is inside the 'data' payload.
+       The union describes the data content, not the SSE envelope.
+       -> Returns: json.loads(data) parsed into the type
+
+    2. Event-level discrimination: The discriminator (e.g., 'event') is at the SSE event level.
+       The union describes the full SSE event structure.
+       -> Returns: SSE envelope with 'data' field JSON-parsed only if the variant expects non-string
+
+    Args:
+        sse: The ServerSentEvent object to parse
+        type_: The target discriminated union type
+
+    Returns:
+        The parsed object of type T
+
+    Note:
+        This function is only available in SDK contexts where http_sse module exists.
+    """
+    sse_event = asdict(sse)
+    discriminator, variants = _get_discriminator_and_variants(type_)
+
+    if discriminator is None or variants is None:
+        # Not a discriminated union - parse the data field as JSON
+        data_value = sse_event.get("data")
+        if isinstance(data_value, str) and data_value:
+            try:
+                parsed_data = json.loads(data_value)
+                return parse_obj_as(type_, parsed_data)
+            except json.JSONDecodeError as e:
+                _logger.warning(
+                    "Failed to parse SSE data field as JSON: %s, data: %s",
+                    e,
+                    data_value[:100] if len(data_value) > 100 else data_value,
+                )
+        return parse_obj_as(type_, sse_event)
+
+    data_value = sse_event.get("data")
+
+    # Check if discriminator is at the top level (event-level discrimination)
+    if discriminator in sse_event:
+        # Case 2: Event-level discrimination
+        # Find the matching variant to check if 'data' field needs JSON parsing
+        disc_value = sse_event.get(discriminator)
+        matching_variant = _find_variant_by_discriminator(variants, discriminator, disc_value)
+
+        if matching_variant is not None:
+            # Check what type the variant expects for 'data'
+            data_type = _get_field_annotation(matching_variant, "data")
+            if data_type is not None and not _is_string_type(data_type):
+                # Variant expects non-string data - parse JSON
+                if isinstance(data_value, str) and data_value:
+                    try:
+                        parsed_data = json.loads(data_value)
+                        new_object = dict(sse_event)
+                        new_object["data"] = parsed_data
+                        return parse_obj_as(type_, new_object)
+                    except json.JSONDecodeError as e:
+                        _logger.warning(
+                            "Failed to parse SSE data field as JSON for event-level discrimination: %s, data: %s",
+                            e,
+                            data_value[:100] if len(data_value) > 100 else data_value,
+                        )
+        # Either no matching variant, data is string type, or JSON parse failed
+        return parse_obj_as(type_, sse_event)
+
+    else:
+        # Case 1: Data-level discrimination
+        # The discriminator is inside the data payload - extract and parse data only
+        if isinstance(data_value, str) and data_value:
+            try:
+                parsed_data = json.loads(data_value)
+                return parse_obj_as(type_, parsed_data)
+            except json.JSONDecodeError as e:
+                _logger.warning(
+                    "Failed to parse SSE data field as JSON for data-level discrimination: %s, data: %s",
+                    e,
+                    data_value[:100] if len(data_value) > 100 else data_value,
+                )
+        return parse_obj_as(type_, sse_event)
+
+
 def parse_obj_as(type_: Type[T], object_: Any) -> T:
     if IS_PYDANTIC_V2:
         adapter = pydantic.TypeAdapter(type_)  # type: ignore[attr-defined]
@@ -51,13 +312,37 @@ def to_jsonable_with_fallback(obj: Any, fallback_serializer: Callable[[Any], Any
 
 
 class UniversalBaseModel(pydantic.BaseModel):
-    class Config:
-        populate_by_name = True
-        smart_union = True
-        allow_population_by_field_name = True
-        json_encoders = {dt.datetime: serialize_datetime}
-        # Allow fields beginning with `model_` to be used in the model
-        protected_namespaces = ()
+    if IS_PYDANTIC_V2:
+        model_config: ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(  # type: ignore[typeddict-unknown-key]
+            validate_by_name=True,
+            validate_by_alias=True,
+            # Allow fields beginning with `model_` to be used in the model
+            protected_namespaces=(),
+        )
+
+        @pydantic.model_serializer(mode="plain", when_used="json")  # type: ignore[attr-defined]
+        def serialize_model(self) -> Any:  # type: ignore[name-defined]
+            def _serialize_recursive(obj: Any) -> Any:
+                if isinstance(obj, dt.datetime):
+                    return serialize_datetime(obj)
+                elif isinstance(obj, dict):
+                    return {k: _serialize_recursive(v) for k, v in obj.items()}
+                elif isinstance(obj, list):
+                    return [_serialize_recursive(item) for item in obj]
+                return obj
+
+            serialized = self.model_dump()  # type: ignore[attr-defined]
+            return _serialize_recursive(serialized)
+
+    else:
+
+        class Config:
+            populate_by_name = True
+            smart_union = True
+            allow_population_by_field_name = True
+            json_encoders = {dt.datetime: serialize_datetime}
+            # Allow fields beginning with `model_` to be used in the model
+            protected_namespaces = ()
 
     def json(self, **kwargs: Any) -> str:
         kwargs_with_defaults = {
@@ -185,10 +470,14 @@ def update_forward_refs(model: Type["Model"], **localns: Any) -> None:
 AnyCallable = Callable[..., Any]
 
 
-def universal_root_validator(pre: bool = False) -> Callable[[AnyCallable], AnyCallable]:
+def universal_root_validator(
+    pre: bool = False,
+) -> Callable[[AnyCallable], AnyCallable]:
     def decorator(func: AnyCallable) -> AnyCallable:
         if IS_PYDANTIC_V2:
-            return cast(AnyCallable, pydantic.model_validator(mode="before" if pre else "after")(func))  # type: ignore[attr-defined]
+            # In Pydantic v2, for RootModel we always use "before" mode
+            # The custom validators transform the input value before the model is created
+            return cast(AnyCallable, pydantic.model_validator(mode="before")(func))  # type: ignore[attr-defined]
         return cast(AnyCallable, pydantic.root_validator(pre=pre)(func))  # type: ignore[call-overload]
 
     return decorator
@@ -203,7 +492,7 @@ def universal_field_validator(field_name: str, pre: bool = False) -> Callable[[A
     return decorator
 
 
-PydanticField = Union[ModelField, pydantic.fields.FieldInfo]
+PydanticField = Union[ModelField, _FieldInfo]
 
 
 def _get_model_fields(model: Type["Model"]) -> Mapping[str, PydanticField]:

merge/core/unchecked_base_model.py

@@ -1,13 +1,15 @@
 # This file was auto-generated by Fern from our API Definition.
 
 import datetime as dt
+import enum
 import inspect
+import sys
 import typing
 import uuid
 
 import pydantic
 import typing_extensions
-from .pydantic_utilities import (
+from .pydantic_utilities import (  # type: ignore[attr-defined]
     IS_PYDANTIC_V2,
     ModelField,
     UniversalBaseModel,
@@ -33,6 +35,28 @@ class UnionMetadata:
 Model = typing.TypeVar("Model", bound=pydantic.BaseModel)
 
 
+def _maybe_resolve_forward_ref(
+    type_: typing.Any,
+    host: typing.Optional[typing.Type[typing.Any]],
+) -> typing.Any:
+    """Resolve a ForwardRef using the module where *host* is defined.
+
+    Pydantic v2 + ``from __future__ import annotations`` can leave field
+    annotations as ``list[ForwardRef('Block')]`` even after ``model_rebuild``.
+    Without resolution, ``construct_type`` sees a ForwardRef (not a class) and
+    skips recursive model construction, leaving nested data as raw dicts.
+    """
+    if host is None or not isinstance(type_, typing.ForwardRef):
+        return type_
+    mod = sys.modules.get(host.__module__)
+    if mod is None:
+        return type_
+    try:
+        return eval(type_.__forward_arg__, vars(mod))
+    except Exception:
+        return type_
+
+
 class UncheckedBaseModel(UniversalBaseModel):
     if IS_PYDANTIC_V2:
         model_config: typing.ClassVar[pydantic.ConfigDict] = pydantic.ConfigDict(extra="allow")  # type: ignore # Pydantic v2
@@ -86,7 +110,7 @@ class UncheckedBaseModel(UniversalBaseModel):
                     type_ = typing.cast(typing.Type, field.outer_type_)  # type: ignore # Pydantic < v1.10.15
 
                 fields_values[name] = (
-                    construct_type(object_=values[key], type_=type_) if type_ is not None else values[key]
+                    construct_type(object_=values[key], type_=type_, host=cls) if type_ is not None else values[key]
                 )
                 _fields_set.add(name)
             else:
@@ -150,15 +174,75 @@ def _validate_collection_items_compatible(collection: typing.Any, target_type: t
     return True
 
 
-def _convert_undiscriminated_union_type(union_type: typing.Type[typing.Any], object_: typing.Any) -> typing.Any:
+def _get_literal_field_value(
+    inner_type: typing.Type[typing.Any], field_name: str, field: typing.Any, object_: typing.Any
+) -> typing.Any:
+    """Get the value of a Literal field from *object_*, checking both alias and field name."""
+    name_or_alias = get_field_to_alias_mapping(inner_type).get(field_name, field_name)
+    pydantic_alias = getattr(field, "alias", None)
+    if isinstance(object_, dict):
+        if name_or_alias in object_:
+            return object_[name_or_alias]
+        if pydantic_alias and pydantic_alias != name_or_alias and pydantic_alias in object_:
+            return object_[pydantic_alias]
+        return None
+    return getattr(object_, name_or_alias, getattr(object_, pydantic_alias, None) if pydantic_alias else None)
+
+
+def _literal_fields_match_strict(inner_type: typing.Type[typing.Any], object_: typing.Any) -> bool:
+    """Return True iff every Literal-typed field in *inner_type* is **present** in
+    *object_* and its value equals the field's declared default.
+
+    This prevents models whose fields are all optional (e.g. ``FigureDetails``)
+    from vacuously matching inputs that don't carry the discriminant key at all
+    (e.g. ``{}`` for text blocks).  For types with no Literal fields this
+    returns True unconditionally.
+    """
+    fields = _get_model_fields(inner_type)
+    for field_name, field in fields.items():
+        if IS_PYDANTIC_V2:
+            field_type = field.annotation  # type: ignore # Pydantic v2
+        else:
+            field_type = field.outer_type_  # type: ignore # Pydantic v1
+
+        if is_literal_type(field_type):  # type: ignore[arg-type]
+            field_default = _get_field_default(field)
+            object_value = _get_literal_field_value(inner_type, field_name, field, object_)
+            if field_default != object_value:
+                return False
+    return True
+
+
+def _convert_undiscriminated_union_type(
+    union_type: typing.Type[typing.Any],
+    object_: typing.Any,
+    host: typing.Optional[typing.Type[typing.Any]] = None,
+) -> typing.Any:
     inner_types = get_args(union_type)
     if typing.Any in inner_types:
         return object_
 
+    # When any union member carries a Literal discriminant field, require the
+    # discriminant key to be present AND matching before accepting a candidate.
+    # This prevents models with all-optional fields (e.g. FigureDetails) from
+    # greedily matching inputs that belong to a different variant or to a
+    # plain-dict fallback (e.g. EmptyBlockDetails = Dict[str, Any]).
+    has_literal_discriminant = any(
+        inspect.isclass(t)
+        and issubclass(t, pydantic.BaseModel)
+        and any(
+            is_literal_type(
+                f.annotation if IS_PYDANTIC_V2 else f.outer_type_  # type: ignore
+            )
+            for f in _get_model_fields(t).values()
+        )
+        for t in inner_types
+    )
+
     for inner_type in inner_types:
         # Handle lists of objects that need parsing
         if get_origin(inner_type) is list and isinstance(object_, list):
-            list_inner_type = get_args(inner_type)[0]
+            list_inner_type = _maybe_resolve_forward_ref(get_args(inner_type)[0], host)
             try:
                 if inspect.isclass(list_inner_type) and issubclass(list_inner_type, pydantic.BaseModel):
                     # Validate that all items in the list are compatible with the target type
@@ -170,20 +254,63 @@ def _convert_undiscriminated_union_type(union_type: typing.Type[typing.Any], obj
 
         try:
             if inspect.isclass(inner_type) and issubclass(inner_type, pydantic.BaseModel):
+                if has_literal_discriminant and not _literal_fields_match_strict(inner_type, object_):
+                    continue
                 # Attempt a validated parse until one works
                 return parse_obj_as(inner_type, object_)
         except Exception:
             continue
 
-    # If none of the types work, just return the first successful cast
+    # First pass: try types where all literal fields match the object's values.
+    for inner_type in inner_types:
+        if inspect.isclass(inner_type) and issubclass(inner_type, pydantic.BaseModel):
+            if has_literal_discriminant:
+                if not _literal_fields_match_strict(inner_type, object_):
+                    continue
+            else:
+                # Legacy lenient check: skip only when a Literal value is
+                # present but doesn't match (allows absent-discriminant inputs).
+                fields = _get_model_fields(inner_type)
+                literal_fields_match = True
+                for field_name, field in fields.items():
+                    if IS_PYDANTIC_V2:
+                        field_type = field.annotation  # type: ignore # Pydantic v2
+                    else:
+                        field_type = field.outer_type_  # type: ignore # Pydantic v1
+
+                    if is_literal_type(field_type):  # type: ignore[arg-type]
+                        field_default = _get_field_default(field)
+                        object_value = _get_literal_field_value(inner_type, field_name, field, object_)
+                        if object_value is not None and field_default != object_value:
+                            literal_fields_match = False
+                            break
+
+                if not literal_fields_match:
+                    continue
+
+            try:
+                return construct_type(object_=object_, type_=inner_type, host=host)
+            except Exception:
+                continue
+
+    # Second pass: if no literal matches, return the first successful cast.
+    # When a Literal discriminant is present, skip Pydantic models whose
+    # discriminant doesn't match so that plain-dict fallback types are reached.
     for inner_type in inner_types:
         try:
-            return construct_type(object_=object_, type_=inner_type)
+            if has_literal_discriminant and inspect.isclass(inner_type) and issubclass(inner_type, pydantic.BaseModel):
+                if not _literal_fields_match_strict(inner_type, object_):
+                    continue
+            return construct_type(object_=object_, type_=inner_type, host=host)
         except Exception:
             continue
 
 
-def _convert_union_type(type_: typing.Type[typing.Any], object_: typing.Any) -> typing.Any:
+def _convert_union_type(
+    type_: typing.Type[typing.Any],
+    object_: typing.Any,
+    host: typing.Optional[typing.Type[typing.Any]] = None,
+) -> typing.Any:
     base_type = get_origin(type_) or type_
     union_type = type_
     if base_type == typing_extensions.Annotated:  # type: ignore[comparison-overlap]
@@ -199,14 +326,19 @@ def _convert_union_type(type_: typing.Type[typing.Any], object_: typing.Any) ->
                         except:
                             objects_discriminant = object_[metadata.discriminant]
                         if inner_type.__fields__[metadata.discriminant].default == objects_discriminant:
-                            return construct_type(object_=object_, type_=inner_type)
+                            return construct_type(object_=object_, type_=inner_type, host=host)
                 except Exception:
                     # Allow to fall through to our regular union handling
                     pass
-    return _convert_undiscriminated_union_type(union_type, object_)
+    return _convert_undiscriminated_union_type(union_type, object_, host)
 
 
-def construct_type(*, type_: typing.Type[typing.Any], object_: typing.Any) -> typing.Any:
+def construct_type(
+    *,
+    type_: typing.Type[typing.Any],
+    object_: typing.Any,
+    host: typing.Optional[typing.Type[typing.Any]] = None,
+) -> typing.Any:
     """
     Here we are essentially creating the same `construct` method in spirit as the above, but for all types, not just
     Pydantic models.
@@ -229,8 +361,12 @@ def construct_type(*, type_: typing.Type[typing.Any], object_: typing.Any) -> ty
             return object_
 
         key_type, items_type = get_args(type_)
+        key_type = _maybe_resolve_forward_ref(key_type, host)
+        items_type = _maybe_resolve_forward_ref(items_type, host)
         d = {
-            construct_type(object_=key, type_=key_type): construct_type(object_=item, type_=items_type)
+            construct_type(object_=key, type_=key_type, host=host): construct_type(
+                object_=item, type_=items_type, host=host
+            )
             for key, item in object_.items()
         }
         return d
@@ -239,18 +375,18 @@ def construct_type(*, type_: typing.Type[typing.Any], object_: typing.Any) -> ty
         if not isinstance(object_, list):
             return object_
 
-        inner_type = get_args(type_)[0]
-        return [construct_type(object_=entry, type_=inner_type) for entry in object_]
+        inner_type = _maybe_resolve_forward_ref(get_args(type_)[0], host)
+        return [construct_type(object_=entry, type_=inner_type, host=host) for entry in object_]
 
     if base_type == set:
         if not isinstance(object_, set) and not isinstance(object_, list):
             return object_
 
-        inner_type = get_args(type_)[0]
-        return {construct_type(object_=entry, type_=inner_type) for entry in object_}
+        inner_type = _maybe_resolve_forward_ref(get_args(type_)[0], host)
+        return {construct_type(object_=entry, type_=inner_type, host=host) for entry in object_}
 
     if is_union(base_type) or is_annotated_union:
-        return _convert_union_type(type_, object_)
+        return _convert_union_type(type_, object_, host)
 
     # Cannot do an `issubclass` with a literal type, let's also just confirm we have a class before this call
     if (
@@ -304,6 +440,8 @@ def construct_type(*, type_: typing.Type[typing.Any], object_: typing.Any) -> ty
         except Exception:
             return object_
 
+    # MERGE CUSTOMIZATION: return raw enum values instead of coercing to enum
+    # members, to preserve forward-compatible behavior for customers.
     return object_
 
 
@@ -313,7 +451,9 @@ def _get_is_populate_by_name(model: typing.Type["Model"]) -> bool:
     return model.__config__.allow_population_by_field_name  # type: ignore # Pydantic v1
 
 
-PydanticField = typing.Union[ModelField, pydantic.fields.FieldInfo]
+from pydantic.fields import FieldInfo as _FieldInfo
+
+PydanticField = typing.Union[ModelField, _FieldInfo]
 
 
 # Pydantic V1 swapped the typing of __fields__'s values from ModelField to FieldInfo