rappel 0.4.1__py3-none-win_amd64.whl → 0.8.1__py3-none-win_amd64.whl

rappel/registry.py

@@ -29,6 +29,32 @@ class ActionRegistry:
         self._actions: dict[str, _ActionEntry] = {}
         self._lock = RLock()
 
+    def _source_fingerprint(self, func: AsyncAction) -> tuple[str | None, str | None]:
+        func_any: Any = func
+        try:
+            code = func_any.__code__
+        except AttributeError:
+            return (None, None)
+        try:
+            qualname = func_any.__qualname__
+        except AttributeError:
+            qualname = None
+        filename = code.co_filename
+        if not isinstance(filename, str):
+            filename = None
+        if qualname is not None and not isinstance(qualname, str):
+            qualname = None
+        return (filename, qualname)
+
+    def _is_same_action_definition(self, existing: AsyncAction, new: AsyncAction) -> bool:
+        if existing is new:
+            return True
+        existing_fingerprint = self._source_fingerprint(existing)
+        new_fingerprint = self._source_fingerprint(new)
+        if existing_fingerprint == (None, None) or new_fingerprint == (None, None):
+            return False
+        return existing_fingerprint == new_fingerprint
+
     def register(self, module: str, name: str, func: AsyncAction) -> None:
         """Register an action with its module and name.
 
@@ -38,11 +64,16 @@ class ActionRegistry:
             func: The async function to execute.
 
         Raises:
-            ValueError: If an action with the same module:name is already registered.
+            ValueError: If an action with the same module:name is already registered
+                with a different implementation.
         """
         key = _make_key(module, name)
         with self._lock:
-            if key in self._actions:
+            existing = self._actions.get(key)
+            if existing is not None:
+                if self._is_same_action_definition(existing.func, func):
+                    self._actions[key] = _ActionEntry(module=module, name=name, func=func)
+                    return
                 raise ValueError(f"action '{module}:{name}' already registered")
             self._actions[key] = _ActionEntry(module=module, name=name, func=func)
 
@@ -66,6 +97,11 @@ class ActionRegistry:
         with self._lock:
             return sorted(self._actions.keys())
 
+    def entries(self) -> list[_ActionEntry]:
+        """Return all registered action entries."""
+        with self._lock:
+            return list(self._actions.values())
+
     def reset(self) -> None:
         """Clear all registered actions."""
         with self._lock:

rappel/schedule.py

@@ -9,12 +9,12 @@ from dataclasses import dataclass
 from datetime import datetime, timedelta
 from typing import Any, Dict, List, Literal, Optional, Type, Union
 
-from grpc import aio  # type: ignore[attr-defined]
+from grpc import StatusCode, aio  # type: ignore[attr-defined]
 
 from proto import messages_pb2 as pb2
 
 from .bridge import _workflow_stub, ensure_singleton
-from .serialization import build_arguments_from_kwargs
+from .exceptions import ScheduleAlreadyExistsError
 from .workflow import Workflow
 
 ScheduleType = Literal["cron", "interval"]
@@ -27,9 +27,11 @@ class ScheduleInfo:
 
     id: str
     workflow_name: str
+    schedule_name: str
     schedule_type: ScheduleType
     cron_expression: Optional[str]
     interval_seconds: Optional[int]
+    jitter_seconds: Optional[int]
     status: ScheduleStatus
     next_run_at: Optional[datetime]
     last_run_at: Optional[datetime]
@@ -41,7 +43,9 @@ class ScheduleInfo:
 async def schedule_workflow(
     workflow_cls: Type[Workflow],
     *,
+    schedule_name: str,
     schedule: Union[str, timedelta],
+    jitter: Optional[timedelta] = None,
     inputs: Optional[Dict[str, Any]] = None,
 ) -> str:
     """
@@ -53,8 +57,12 @@ async def schedule_workflow(
 
     Args:
         workflow_cls: The Workflow class to schedule.
+        schedule_name: Unique name for this schedule. Allows multiple schedules
+                       per workflow with different inputs. Must be unique within
+                       a workflow.
         schedule: Either a cron expression string (e.g., "0 * * * *" for hourly)
                   or a timedelta for interval-based scheduling.
+        jitter: Optional jitter window to add to each scheduled run.
         inputs: Optional keyword arguments to pass to each scheduled run.
 
     Returns:
@@ -62,22 +70,42 @@ async def schedule_workflow(
 
     Examples:
         # Run every hour at minute 0
-        await schedule_workflow(MyWorkflow, schedule="0 * * * *")
+        await schedule_workflow(
+            MyWorkflow,
+            schedule_name="hourly-run",
+            schedule="0 * * * *"
+        )
 
         # Run every 5 minutes
-        await schedule_workflow(MyWorkflow, schedule=timedelta(minutes=5))
+        await schedule_workflow(
+            MyWorkflow,
+            schedule_name="frequent-check",
+            schedule=timedelta(minutes=5)
+        )
 
-        # Run daily at midnight with inputs
+        # Multiple schedules with different inputs
         await schedule_workflow(
             MyWorkflow,
+            schedule_name="small-batch",
             schedule="0 0 * * *",
             inputs={"batch_size": 100}
         )
+        await schedule_workflow(
+            MyWorkflow,
+            schedule_name="large-batch",
+            schedule="0 12 * * *",
+            inputs={"batch_size": 1000}
+        )
 
     Raises:
-        ValueError: If the cron expression is invalid or interval is non-positive.
+        ValueError: If the cron expression is invalid, interval is non-positive,
+                    or schedule_name is empty.
+        ScheduleAlreadyExistsError: If a schedule with the same name already exists.
         RuntimeError: If the gRPC call fails.
     """
+    if not schedule_name:
+        raise ValueError("schedule_name is required")
+
     workflow_name = workflow_cls.short_name()
 
     # Build schedule definition
@@ -94,6 +122,12 @@ async def schedule_workflow(
     else:
         raise TypeError(f"schedule must be str or timedelta, got {type(schedule)}")
 
+    if jitter is not None:
+        jitter_seconds = int(jitter.total_seconds())
+        if jitter_seconds < 0:
+            raise ValueError("jitter must be non-negative")
+        schedule_def.jitter_seconds = jitter_seconds
+
     # Build the workflow registration payload to ensure the DAG is registered
     # This is required for the schedule to execute - the scheduler needs a
     # registered workflow version to create instances from.
@@ -102,13 +136,14 @@ async def schedule_workflow(
     # Build request with both registration and schedule
     request = pb2.RegisterScheduleRequest(
         workflow_name=workflow_name,
+        schedule_name=schedule_name,
         schedule=schedule_def,
         registration=registration,
     )
 
-    # Add inputs if provided
-    if inputs:
-        request.inputs.CopyFrom(build_arguments_from_kwargs(inputs))
+    initial_context = workflow_cls._build_initial_context((), inputs or {})
+    if initial_context.arguments:
+        request.inputs.CopyFrom(initial_context)
 
     # Send to server
     async with ensure_singleton():
@@ -117,12 +152,16 @@ async def schedule_workflow(
     try:
         response = await stub.RegisterSchedule(request, timeout=30.0)
     except aio.AioRpcError as exc:
+        if exc.code() == StatusCode.ALREADY_EXISTS:
+            raise ScheduleAlreadyExistsError(
+                f"schedule already exists: {workflow_name}/{schedule_name}"
+            ) from exc
         raise RuntimeError(f"Failed to register schedule: {exc}") from exc
 
     return response.schedule_id
 
 
-async def pause_schedule(workflow_cls: Type[Workflow]) -> bool:
+async def pause_schedule(workflow_cls: Type[Workflow], *, schedule_name: str) -> bool:
     """
     Pause a workflow's schedule.
 
@@ -131,12 +170,21 @@ async def pause_schedule(workflow_cls: Type[Workflow]) -> bool:
 
     Args:
         workflow_cls: The Workflow class whose schedule to pause.
+        schedule_name: The name of the schedule to pause.
 
     Returns:
         True if a schedule was found and paused, False otherwise.
+
+    Raises:
+        ValueError: If schedule_name is empty.
+        RuntimeError: If the gRPC call fails.
     """
+    if not schedule_name:
+        raise ValueError("schedule_name is required")
+
     request = pb2.UpdateScheduleStatusRequest(
         workflow_name=workflow_cls.short_name(),
+        schedule_name=schedule_name,
         status=pb2.SCHEDULE_STATUS_PAUSED,
     )
     async with ensure_singleton():
@@ -150,18 +198,27 @@ async def pause_schedule(workflow_cls: Type[Workflow]) -> bool:
     return response.success
 
 
-async def resume_schedule(workflow_cls: Type[Workflow]) -> bool:
+async def resume_schedule(workflow_cls: Type[Workflow], *, schedule_name: str) -> bool:
     """
     Resume a paused workflow schedule.
 
     Args:
         workflow_cls: The Workflow class whose schedule to resume.
+        schedule_name: The name of the schedule to resume.
 
     Returns:
         True if a schedule was found and resumed, False otherwise.
+
+    Raises:
+        ValueError: If schedule_name is empty.
+        RuntimeError: If the gRPC call fails.
     """
+    if not schedule_name:
+        raise ValueError("schedule_name is required")
+
     request = pb2.UpdateScheduleStatusRequest(
         workflow_name=workflow_cls.short_name(),
+        schedule_name=schedule_name,
         status=pb2.SCHEDULE_STATUS_ACTIVE,
     )
     async with ensure_singleton():
@@ -175,7 +232,7 @@ async def resume_schedule(workflow_cls: Type[Workflow]) -> bool:
     return response.success
 
 
-async def delete_schedule(workflow_cls: Type[Workflow]) -> bool:
+async def delete_schedule(workflow_cls: Type[Workflow], *, schedule_name: str) -> bool:
     """
     Delete a workflow's schedule.
 
@@ -184,12 +241,21 @@ async def delete_schedule(workflow_cls: Type[Workflow]) -> bool:
 
     Args:
         workflow_cls: The Workflow class whose schedule to delete.
+        schedule_name: The name of the schedule to delete.
 
     Returns:
         True if a schedule was found and deleted, False otherwise.
+
+    Raises:
+        ValueError: If schedule_name is empty.
+        RuntimeError: If the gRPC call fails.
     """
+    if not schedule_name:
+        raise ValueError("schedule_name is required")
+
     request = pb2.DeleteScheduleRequest(
         workflow_name=workflow_cls.short_name(),
+        schedule_name=schedule_name,
     )
     async with ensure_singleton():
         stub = await _workflow_stub()
@@ -279,9 +345,11 @@ async def list_schedules(
             ScheduleInfo(
                 id=s.id,
                 workflow_name=s.workflow_name,
+                schedule_name=s.schedule_name,
                 schedule_type=_proto_schedule_type_to_str(s.schedule_type),
                 cron_expression=s.cron_expression if s.cron_expression else None,
                 interval_seconds=s.interval_seconds if s.interval_seconds else None,
+                jitter_seconds=s.jitter_seconds if s.jitter_seconds else None,
                 status=_proto_schedule_status_to_str(s.status),
                 next_run_at=_parse_iso_datetime(s.next_run_at),
                 last_run_at=_parse_iso_datetime(s.last_run_at),

rappel/serialization.py

@@ -1,7 +1,13 @@
 import dataclasses
 import importlib
 import traceback
+from base64 import b64encode
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from enum import Enum
+from pathlib import PurePath
 from typing import Any
+from uuid import UUID
 
 from google.protobuf import json_format, struct_pb2
 from pydantic import BaseModel
@@ -55,12 +61,68 @@ def _to_argument_value(value: Any) -> pb2.WorkflowArgumentValue:
     if isinstance(value, PRIMITIVE_TYPES):
         argument.primitive.CopyFrom(_serialize_primitive(value))
         return argument
+    if isinstance(value, UUID):
+        # Serialize UUID as string primitive
+        argument.primitive.CopyFrom(_serialize_primitive(str(value)))
+        return argument
+    if isinstance(value, datetime):
+        # Serialize datetime as ISO format string
+        argument.primitive.CopyFrom(_serialize_primitive(value.isoformat()))
+        return argument
+    if isinstance(value, date):
+        # Serialize date as ISO format string (must come after datetime check)
+        argument.primitive.CopyFrom(_serialize_primitive(value.isoformat()))
+        return argument
+    if isinstance(value, time):
+        # Serialize time as ISO format string
+        argument.primitive.CopyFrom(_serialize_primitive(value.isoformat()))
+        return argument
+    if isinstance(value, timedelta):
+        # Serialize timedelta as total seconds
+        argument.primitive.CopyFrom(_serialize_primitive(value.total_seconds()))
+        return argument
+    if isinstance(value, Decimal):
+        # Serialize Decimal as string to preserve precision
+        argument.primitive.CopyFrom(_serialize_primitive(str(value)))
+        return argument
+    if isinstance(value, Enum):
+        # Serialize Enum as its value
+        return _to_argument_value(value.value)
+    if isinstance(value, bytes):
+        # Serialize bytes as base64 string
+        argument.primitive.CopyFrom(_serialize_primitive(b64encode(value).decode("ascii")))
+        return argument
+    if isinstance(value, PurePath):
+        # Serialize Path as string
+        argument.primitive.CopyFrom(_serialize_primitive(str(value)))
+        return argument
+    if isinstance(value, (set, frozenset)):
+        # Serialize sets as lists
+        argument.list_value.SetInParent()
+        for item in value:
+            item_value = argument.list_value.items.add()
+            item_value.CopyFrom(_to_argument_value(item))
+        return argument
     if isinstance(value, BaseException):
         argument.exception.type = value.__class__.__name__
         argument.exception.module = value.__class__.__module__
         argument.exception.message = str(value)
         tb_text = "".join(traceback.format_exception(type(value), value, value.__traceback__))
         argument.exception.traceback = tb_text
+        # Include the exception class hierarchy (MRO) for proper except matching.
+        # This allows `except LookupError:` to catch KeyError, etc.
+        for cls in value.__class__.__mro__:
+            if cls is object:
+                continue  # Skip 'object' as it's not useful for exception matching
+            argument.exception.type_hierarchy.append(cls.__name__)
+        values = _serialize_exception_values(value)
+        for key, item in values.items():
+            entry = argument.exception.values.entries.add()
+            entry.key = key
+            try:
+                entry.value.CopyFrom(_to_argument_value(item))
+            except TypeError:
+                entry.value.CopyFrom(_to_argument_value(str(item)))
         return argument
     if _is_base_model(value):
         model_class = value.__class__
@@ -121,11 +183,16 @@ def _from_argument_value(argument: pb2.WorkflowArgumentValue) -> Any:
             data[entry.key] = _from_argument_value(entry.value)
         return _instantiate_serialized_model(module, name, data)
     if kind == "exception":
+        values: dict[str, Any] = {}
+        if argument.exception.HasField("values"):
+            for entry in argument.exception.values.entries:
+                values[entry.key] = _from_argument_value(entry.value)
         return {
             "type": argument.exception.type,
             "module": argument.exception.module,
             "message": argument.exception.message,
             "traceback": argument.exception.traceback,
+            "values": values,
         }
     if kind == "list_value":
         return [_from_argument_value(item) for item in argument.list_value.items]
@@ -141,12 +208,19 @@ def _from_argument_value(argument: pb2.WorkflowArgumentValue) -> Any:
 
 def _serialize_model_data(model: BaseModel) -> dict[str, Any]:
     if hasattr(model, "model_dump"):
-        return model.model_dump(mode="python")  # type: ignore[attr-defined]
+        return model.model_dump(mode="json")  # type: ignore[attr-defined]
     if hasattr(model, "dict"):
         return model.dict()  # type: ignore[attr-defined]
     return model.__dict__
 
 
+def _serialize_exception_values(exc: BaseException) -> dict[str, Any]:
+    values = dict(vars(exc))
+    if "args" not in values:
+        values["args"] = exc.args
+    return values
+
+
 def _serialize_primitive(value: Any) -> pb2.PrimitiveWorkflowArgument:
     primitive = pb2.PrimitiveWorkflowArgument()
     if value is None:

rappel/workflow.py

@@ -60,9 +60,34 @@ class Workflow:
     _ir_lock: ClassVar[RLock] = RLock()
     _workflow_version_id: ClassVar[Optional[str]] = None
 
-    async def run(self) -> Any:
+    async def run(self, *args: Any, _blocking: bool = True, **kwargs: Any) -> Any:
         raise NotImplementedError
 
+    @classmethod
+    def _normalize_run_inputs(cls, args: tuple[Any, ...], kwargs: dict[str, Any]) -> dict[str, Any]:
+        try:
+            run_impl = cls.__workflow_run_impl__  # type: ignore[attr-defined]
+        except AttributeError:
+            run_impl = cls.run
+        sig = inspect.signature(run_impl)
+        params = list(sig.parameters.keys())[1:]  # Skip 'self'
+
+        normalized = dict(kwargs)
+        for i, arg in enumerate(args):
+            if i < len(params):
+                normalized[params[i]] = arg
+
+        bound = sig.bind_partial(None, **normalized)
+        bound.apply_defaults()
+        return {key: value for key, value in bound.arguments.items() if key != "self"}
+
+    @classmethod
+    def _build_initial_context(
+        cls, args: tuple[Any, ...], kwargs: dict[str, Any]
+    ) -> pb2.WorkflowArguments:
+        initial_kwargs = cls._normalize_run_inputs(args, kwargs)
+        return build_arguments_from_kwargs(initial_kwargs)
+
     async def run_action(
         self,
         awaitable: Awaitable[TResult],
@@ -163,26 +188,20 @@ def workflow(cls: type[TWorkflow]) -> type[TWorkflow]:
         raise TypeError("workflow run() must be defined with 'async def'")
 
     @wraps(run_impl)
-    async def run_public(self: Workflow, *args: Any, **kwargs: Any) -> Any:
+    async def run_public(self: Workflow, *args: Any, _blocking: bool = True, **kwargs: Any) -> Any:
         if _running_under_pytest():
             cls.workflow_ir()
             return await run_impl(self, *args, **kwargs)
 
-        # Get the signature of run() to map positional args to parameter names
-        sig = inspect.signature(run_impl)
-        params = list(sig.parameters.keys())[1:]  # Skip 'self'
-
-        # Convert positional args to kwargs
-        for i, arg in enumerate(args):
-            if i < len(params):
-                kwargs[params[i]] = arg
-
-        # Serialize kwargs using common logic
-        initial_context = build_arguments_from_kwargs(kwargs)
+        initial_context = cls._build_initial_context(args, kwargs)
 
         payload = cls._build_registration_payload(initial_context)
         run_result = await bridge.run_instance(payload.SerializeToString())
         cls._workflow_version_id = run_result.workflow_version_id
+
+        if not _blocking:
+            return run_result.workflow_instance_id
+
         if _skip_wait_for_instance():
             logger.info(
                 "Skipping wait_for_instance for workflow %s due to RAPPEL_SKIP_WAIT_FOR_INSTANCE",

rappel/workflow_runtime.py

@@ -6,8 +6,13 @@ action dispatch commands from the Rust scheduler.
 
 import asyncio
 import dataclasses
+from base64 import b64decode
 from dataclasses import dataclass
-from typing import Any, Dict, get_type_hints
+from datetime import date, datetime, time, timedelta
+from decimal import Decimal
+from pathlib import Path, PurePath
+from typing import Any, Dict, get_args, get_origin, get_type_hints
+from uuid import UUID
 
 from pydantic import BaseModel
 
@@ -45,6 +50,87 @@ def _is_dataclass_type(cls: type) -> bool:
     return dataclasses.is_dataclass(cls) and isinstance(cls, type)
 
 
+def _coerce_primitive(value: Any, target_type: type) -> Any:
+    """Coerce a value to a primitive type based on target_type.
+
+    Handles conversion of serialized values (strings, floats) back to their
+    native Python types (UUID, datetime, etc.).
+    """
+    # Handle None
+    if value is None:
+        return None
+
+    # UUID from string
+    if target_type is UUID:
+        if isinstance(value, UUID):
+            return value
+        if isinstance(value, str):
+            return UUID(value)
+        return value
+
+    # datetime from ISO string
+    if target_type is datetime:
+        if isinstance(value, datetime):
+            return value
+        if isinstance(value, str):
+            return datetime.fromisoformat(value)
+        return value
+
+    # date from ISO string
+    if target_type is date:
+        if isinstance(value, date):
+            return value
+        if isinstance(value, str):
+            return date.fromisoformat(value)
+        return value
+
+    # time from ISO string
+    if target_type is time:
+        if isinstance(value, time):
+            return value
+        if isinstance(value, str):
+            return time.fromisoformat(value)
+        return value
+
+    # timedelta from total seconds
+    if target_type is timedelta:
+        if isinstance(value, timedelta):
+            return value
+        if isinstance(value, (int, float)):
+            return timedelta(seconds=value)
+        return value
+
+    # Decimal from string
+    if target_type is Decimal:
+        if isinstance(value, Decimal):
+            return value
+        if isinstance(value, (str, int, float)):
+            return Decimal(str(value))
+        return value
+
+    # bytes from base64 string
+    if target_type is bytes:
+        if isinstance(value, bytes):
+            return value
+        if isinstance(value, str):
+            return b64decode(value)
+        return value
+
+    # Path from string
+    if target_type is Path or target_type is PurePath:
+        if isinstance(value, PurePath):
+            return value
+        if isinstance(value, str):
+            return Path(value)
+        return value
+
+    return value
+
+
+# Types that can be coerced from serialized form
+COERCIBLE_TYPES = (UUID, datetime, date, time, timedelta, Decimal, bytes, Path, PurePath)
+
+
 def _coerce_dict_to_model(value: Any, target_type: type) -> Any:
     """Convert a dict to a Pydantic model or dataclass if needed.
 
@@ -67,12 +153,76 @@ def _coerce_dict_to_model(value: Any, target_type: type) -> Any:
     return value
 
 
+def _coerce_value(value: Any, target_type: type) -> Any:
+    """Coerce a value to the target type.
+
+    Handles:
+    - Primitive types (UUID, datetime, etc.)
+    - Pydantic models and dataclasses (from dicts)
+    - Generic collections like list[UUID], set[datetime]
+    """
+    # Handle None
+    if value is None:
+        return None
+
+    # Check for coercible primitive types
+    if isinstance(target_type, type) and issubclass(target_type, COERCIBLE_TYPES):
+        return _coerce_primitive(value, target_type)
+
+    # Check for Pydantic models or dataclasses
+    if isinstance(value, dict):
+        coerced = _coerce_dict_to_model(value, target_type)
+        if coerced is not value:
+            return coerced
+
+    # Handle generic types like list[UUID], set[datetime]
+    origin = get_origin(target_type)
+    if origin is not None:
+        args = get_args(target_type)
+
+        # Handle list[T]
+        if origin is list and isinstance(value, list) and args:
+            item_type = args[0]
+            return [_coerce_value(item, item_type) for item in value]
+
+        # Handle set[T] (serialized as list)
+        if origin is set and isinstance(value, list) and args:
+            item_type = args[0]
+            return {_coerce_value(item, item_type) for item in value}
+
+        # Handle frozenset[T] (serialized as list)
+        if origin is frozenset and isinstance(value, list) and args:
+            item_type = args[0]
+            return frozenset(_coerce_value(item, item_type) for item in value)
+
+        # Handle tuple[T, ...] (serialized as list)
+        if origin is tuple and isinstance(value, (list, tuple)) and args:
+            # Variable length tuple like tuple[int, ...]
+            if len(args) == 2 and args[1] is ...:
+                item_type = args[0]
+                return tuple(_coerce_value(item, item_type) for item in value)
+            # Fixed length tuple like tuple[int, str, UUID]
+            return tuple(
+                _coerce_value(item, item_type) for item, item_type in zip(value, args, strict=False)
+            )
+
+        # Handle dict[K, V]
+        if origin is dict and isinstance(value, dict) and len(args) == 2:
+            key_type, val_type = args
+            return {
+                _coerce_value(k, key_type): _coerce_value(v, val_type) for k, v in value.items()
+            }
+
+    return value
+
+
 def _coerce_kwargs_to_type_hints(handler: Any, kwargs: Dict[str, Any]) -> Dict[str, Any]:
-    """Coerce dict kwargs to Pydantic models or dataclasses based on type hints.
+    """Coerce kwargs to expected types based on handler's type hints.
 
-    When the IR converts a Pydantic model or dataclass constructor call to a dict,
-    the action runner needs to convert that dict back to the expected type based
-    on the handler's type annotations.
+    Handles:
+    - Pydantic models and dataclasses (from dicts)
+    - Primitive types like UUID, datetime, Decimal, etc.
+    - Generic collections like list[UUID], dict[str, datetime]
     """
     try:
         type_hints = get_type_hints(handler)
@@ -84,7 +234,7 @@ def _coerce_kwargs_to_type_hints(handler: Any, kwargs: Dict[str, Any]) -> Dict[s
     for key, value in kwargs.items():
         if key in type_hints:
             target_type = type_hints[key]
-            coerced[key] = _coerce_dict_to_model(value, target_type)
+            coerced[key] = _coerce_value(value, target_type)
         else:
             coerced[key] = value