prefect-client 3.2.15.dev9__py3-none-any.whl → 3.3.0__py3-none-any.whl

prefect/states.py

@@ -5,7 +5,6 @@ import datetime
 import sys
 import traceback
 import uuid
-import warnings
 from collections import Counter
 from types import GeneratorType, TracebackType
 from typing import TYPE_CHECKING, Any, Dict, Iterable, Optional, Type
@@ -15,7 +14,6 @@ import httpx
 from opentelemetry import propagate
 from typing_extensions import TypeGuard
 
-from prefect._internal.compatibility import deprecated
 from prefect.client.schemas.objects import State, StateDetails, StateType
 from prefect.exceptions import (
     CancelledRun,
@@ -28,9 +26,9 @@ from prefect.exceptions import (
     UnfinishedRun,
 )
 from prefect.logging.loggers import get_logger, get_run_logger
-from prefect.types._datetime import DateTime, Duration, now
+from prefect.types._datetime import now
 from prefect.utilities.annotations import BaseAnnotation
-from prefect.utilities.asyncutils import in_async_main_thread, sync_compatible
+from prefect.utilities.asyncutils import sync_compatible
 from prefect.utilities.collections import ensure_iterable
 
 if TYPE_CHECKING:
@@ -73,17 +71,9 @@ def to_state_create(state: State) -> "StateCreate":
     )
 
 
-@deprecated.deprecated_parameter(
-    "fetch",
-    when=lambda fetch: fetch is not True,
-    start_date="Oct 2024",
-    end_date="Jan 2025",
-    help="Please ensure you are awaiting the call to `result()` when calling in an async context.",
-)
-def get_state_result(
+async def get_state_result(
     state: "State[R]",
     raise_on_failure: bool = True,
-    fetch: bool = True,
     retry_result_failure: bool = True,
 ) -> "R":
     """
@@ -92,25 +82,11 @@ def get_state_result(
     See `State.result()`
     """
 
-    if not fetch and in_async_main_thread():
-        warnings.warn(
-            (
-                "State.result() was called from an async context but not awaited. "
-                "This method will be updated to return a coroutine by default in "
-                "the future. Pass `fetch=True` and `await` the call to get rid of "
-                "this warning."
-            ),
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        return state.data
-    else:
-        return _get_state_result(
-            state,
-            raise_on_failure=raise_on_failure,
-            retry_result_failure=retry_result_failure,
-        )
+    return await _get_state_result(
+        state,
+        raise_on_failure=raise_on_failure,
+        retry_result_failure=retry_result_failure,
+    )
 
 
 RESULT_READ_MAXIMUM_ATTEMPTS = 10
@@ -155,7 +131,6 @@ async def _get_state_result_data_with_retries(
             await asyncio.sleep(RESULT_READ_RETRY_DELAY)
 
 
-@sync_compatible
 async def _get_state_result(
     state: "State[R]", raise_on_failure: bool, retry_result_failure: bool = True
 ) -> "R":
@@ -759,9 +734,9 @@ def Paused(
         pass
     else:
         state_details.pause_timeout = (
-            DateTime.instance(pause_expiration_time)
+            pause_expiration_time
             if pause_expiration_time
-            else now() + Duration(seconds=timeout_seconds or 0)
+            else now() + datetime.timedelta(seconds=timeout_seconds or 0)
         )
 
     state_details.pause_reschedule = reschedule

prefect/task_engine.py

@@ -8,6 +8,7 @@ import time
 from asyncio import CancelledError
 from contextlib import ExitStack, asynccontextmanager, contextmanager, nullcontext
 from dataclasses import dataclass, field
+from datetime import timedelta
 from functools import partial
 from textwrap import dedent
 from typing import (
@@ -32,6 +33,7 @@ import anyio
 from opentelemetry import trace
 from typing_extensions import ParamSpec, Self
 
+import prefect.types._datetime
 from prefect.cache_policies import CachePolicy
 from prefect.client.orchestration import PrefectClient, SyncPrefectClient, get_client
 from prefect.client.schemas import TaskRun
@@ -80,7 +82,6 @@ from prefect.states import (
 )
 from prefect.telemetry.run_telemetry import RunTelemetry
 from prefect.transactions import IsolationLevel, Transaction, transaction
-from prefect.types._datetime import DateTime, Duration
 from prefect.utilities._engine import get_hook_name
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import run_coro_as_sync
@@ -438,7 +439,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         if last_state.timestamp == new_state.timestamp:
             # Ensure that the state timestamp is unique, or at least not equal to the last state.
             # This might occur especially on Windows where the timestamp resolution is limited.
-            new_state.timestamp += Duration(microseconds=1)
+            new_state.timestamp += timedelta(microseconds=1)
 
         # Ensure that the state_details are populated with the current run IDs
         new_state.state_details.task_run_id = self.task_run.id
@@ -487,7 +488,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     def handle_success(self, result: R, transaction: Transaction) -> R:
         if self.task.cache_expiration is not None:
-            expiration = DateTime.now("utc") + self.task.cache_expiration
+            expiration = prefect.types._datetime.now("UTC") + self.task.cache_expiration
         else:
             expiration = None
 
@@ -536,7 +537,8 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                     else self.task.retry_delay_seconds
                 )
                 new_state = AwaitingRetry(
-                    scheduled_time=DateTime.now("utc").add(seconds=delay)
+                    scheduled_time=prefect.types._datetime.now("UTC")
+                    + timedelta(seconds=delay)
                 )
             else:
                 delay = None
@@ -729,7 +731,9 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
     async def wait_until_ready(self) -> None:
         """Waits until the scheduled time (if its the future), then enters Running."""
         if scheduled_time := self.state.state_details.scheduled_time:
-            sleep_time = (scheduled_time - DateTime.now("utc")).total_seconds()
+            sleep_time = (
+                scheduled_time - prefect.types._datetime.now("UTC")
+            ).total_seconds()
             await anyio.sleep(sleep_time if sleep_time > 0 else 0)
             new_state = Retrying() if self.state.name == "AwaitingRetry" else Running()
             self.set_state(
@@ -968,7 +972,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         if last_state.timestamp == new_state.timestamp:
             # Ensure that the state timestamp is unique, or at least not equal to the last state.
             # This might occur especially on Windows where the timestamp resolution is limited.
-            new_state.timestamp += Duration(microseconds=1)
+            new_state.timestamp += timedelta(microseconds=1)
 
         # Ensure that the state_details are populated with the current run IDs
         new_state.state_details.task_run_id = self.task_run.id
@@ -1018,7 +1022,7 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
     async def handle_success(self, result: R, transaction: Transaction) -> R:
         if self.task.cache_expiration is not None:
-            expiration = DateTime.now("utc") + self.task.cache_expiration
+            expiration = prefect.types._datetime.now("UTC") + self.task.cache_expiration
         else:
             expiration = None
 
@@ -1066,7 +1070,8 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                     else self.task.retry_delay_seconds
                 )
                 new_state = AwaitingRetry(
-                    scheduled_time=DateTime.now("utc").add(seconds=delay)
+                    scheduled_time=prefect.types._datetime.now("UTC")
+                    + timedelta(seconds=delay)
                 )
             else:
                 delay = None
@@ -1257,7 +1262,9 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
     async def wait_until_ready(self) -> None:
         """Waits until the scheduled time (if its the future), then enters Running."""
         if scheduled_time := self.state.state_details.scheduled_time:
-            sleep_time = (scheduled_time - DateTime.now("utc")).total_seconds()
+            sleep_time = (
+                scheduled_time - prefect.types._datetime.now("UTC")
+            ).total_seconds()
             await anyio.sleep(sleep_time if sleep_time > 0 else 0)
             new_state = Retrying() if self.state.name == "AwaitingRetry" else Running()
             await self.set_state(

prefect/task_worker.py

@@ -20,6 +20,7 @@ from fastapi import FastAPI
 from typing_extensions import ParamSpec, Self, TypeVar
 from websockets.exceptions import InvalidStatus
 
+import prefect.types._datetime
 from prefect import Task
 from prefect._internal.concurrency.api import create_call, from_sync
 from prefect.cache_policies import DEFAULT, NO_CACHE
@@ -34,7 +35,7 @@ from prefect.settings import (
 )
 from prefect.states import Pending
 from prefect.task_engine import run_task_async, run_task_sync
-from prefect.types._datetime import DateTime
+from prefect.types import DateTime
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import asyncnullcontext, sync_compatible
 from prefect.utilities.engine import emit_task_run_state_change_event
@@ -256,7 +257,9 @@ class TaskWorker:
                 )
 
     async def _safe_submit_scheduled_task_run(self, task_run: TaskRun):
-        self.in_flight_task_runs[task_run.task_key][task_run.id] = DateTime.now()
+        self.in_flight_task_runs[task_run.task_key][task_run.id] = (
+            prefect.types._datetime.now("UTC")
+        )
         try:
             await self._submit_scheduled_task_run(task_run)
         except BaseException as exc:
@@ -379,7 +382,7 @@ class TaskWorker:
         await self._exit_stack.enter_async_context(self._runs_task_group)
         self._exit_stack.enter_context(self._executor)
 
-        self._started_at = DateTime.now()
+        self._started_at = prefect.types._datetime.now("UTC")
         return self
 
     async def __aexit__(self, *exc_info: Any) -> None:

prefect/tasks.py

@@ -765,6 +765,11 @@ class Task(Generic[P, R]):
     def on_rollback(
         self, fn: Callable[["Transaction"], None]
     ) -> Callable[["Transaction"], None]:
+        if asyncio.iscoroutinefunction(fn):
+            raise ValueError(
+                "Asynchronous rollback hooks are not yet supported. Rollback hooks must be synchronous functions."
+            )
+
         self.on_rollback_hooks.append(fn)
         return fn
 

prefect/telemetry/bootstrap.py

@@ -10,7 +10,9 @@ if TYPE_CHECKING:
 logger: "logging.Logger" = get_logger(__name__)
 
 if TYPE_CHECKING:
-    from opentelemetry.sdk._logs import LoggerProvider
+    from opentelemetry.sdk._logs import (
+        LoggerProvider,  # pyright: ignore[reportPrivateImportUsage]
+    )
     from opentelemetry.sdk.metrics import MeterProvider
     from opentelemetry.sdk.trace import TracerProvider
 

prefect/telemetry/instrumentation.py

@@ -6,10 +6,17 @@ from urllib.parse import urljoin
 from uuid import UUID
 
 from opentelemetry import metrics, trace
-from opentelemetry._logs import set_logger_provider
+from opentelemetry._logs import (
+    set_logger_provider,  # pyright: ignore[reportPrivateImportUsage]
+)
 from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
-from opentelemetry.sdk._logs import LoggerProvider, LoggingHandler
-from opentelemetry.sdk._logs.export import SimpleLogRecordProcessor
+from opentelemetry.sdk._logs import (
+    LoggerProvider,  # pyright: ignore[reportPrivateImportUsage]
+    LoggingHandler,  # pyright: ignore[reportPrivateImportUsage]
+)
+from opentelemetry.sdk._logs.export import (
+    SimpleLogRecordProcessor,  # pyright: ignore[reportPrivateImportUsage]
+)
 from opentelemetry.sdk.metrics import MeterProvider
 from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
 from opentelemetry.sdk.resources import Resource
@@ -20,7 +27,9 @@ from .processors import InFlightSpanProcessor
 from .services import QueueingLogExporter, QueueingSpanExporter
 
 if TYPE_CHECKING:
-    from opentelemetry.sdk._logs import LoggerProvider
+    from opentelemetry.sdk._logs import (
+        LoggerProvider,  # pyright: ignore[reportPrivateImportUsage]
+    )
 
 UUID_REGEX = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 

prefect/telemetry/logging.py

@@ -2,7 +2,9 @@ import logging
 from typing import TYPE_CHECKING, Optional
 
 if TYPE_CHECKING:
-    from opentelemetry.sdk._logs import LoggingHandler
+    from opentelemetry.sdk._logs import (
+        LoggingHandler,  # pyright: ignore[reportPrivateImportUsage]
+    )
 
 _log_handler: Optional["LoggingHandler"] = None
 

prefect/types/_datetime.py

@@ -1,89 +1,119 @@
 from __future__ import annotations
 
 import datetime
-from typing import Any
-
-import pendulum
-import pendulum.tz
-from pendulum.date import Date as PendulumDate
-from pendulum.datetime import DateTime as PendulumDateTime
-from pendulum.duration import Duration as PendulumDuration
-from pendulum.time import Time as PendulumTime
-from pendulum.tz.timezone import FixedTimezone, Timezone
-from pydantic_extra_types.pendulum_dt import (
-    Date as PydanticDate,
-)
-from pydantic_extra_types.pendulum_dt import (
-    DateTime as PydanticDateTime,
-)
-from pydantic_extra_types.pendulum_dt import (
-    Duration as PydanticDuration,
-)
+import sys
+from contextlib import contextmanager
+from typing import Any, cast
+from unittest import mock
+from zoneinfo import ZoneInfo, available_timezones
+
+import humanize
+from dateutil.parser import parse
 from typing_extensions import TypeAlias
 
-DateTime: TypeAlias = PydanticDateTime
-Date: TypeAlias = PydanticDate
-Duration: TypeAlias = PydanticDuration
-UTC: pendulum.tz.Timezone = pendulum.tz.UTC
-
-
-def parse_datetime(
-    value: str,
-    **options: Any,
-) -> PendulumDateTime | PendulumDate | PendulumTime | PendulumDuration:
-    return pendulum.parse(value, **options)
-
-
-def format_diff(
-    diff: PendulumDuration,
-    is_now: bool = True,
-    absolute: bool = False,
-    locale: str | None = None,
-) -> str:
-    return pendulum.format_diff(diff, is_now, absolute, locale)
-
-
-def local_timezone() -> Timezone | FixedTimezone:
-    return pendulum.tz.local_timezone()
+if sys.version_info >= (3, 13):
+    DateTime: TypeAlias = datetime.datetime
+    Date: TypeAlias = datetime.date
+    Duration: TypeAlias = datetime.timedelta
+else:
+    import pendulum
+    import pendulum.tz
+    from pydantic_extra_types.pendulum_dt import (
+        Date as PydanticDate,
+    )
+    from pydantic_extra_types.pendulum_dt import (
+        DateTime as PydanticDateTime,
+    )
+    from pydantic_extra_types.pendulum_dt import (
+        Duration as PydanticDuration,
+    )
+
+    DateTime: TypeAlias = PydanticDateTime
+    Date: TypeAlias = PydanticDate
+    Duration: TypeAlias = PydanticDuration
+
+
+def parse_datetime(dt: str) -> datetime.datetime:
+    if sys.version_info >= (3, 13):
+        parsed_dt = parse(dt)
+        if parsed_dt.tzinfo is None:
+            # Assume UTC if no timezone is provided
+            return parsed_dt.replace(tzinfo=ZoneInfo("UTC"))
+        else:
+            return parsed_dt
+    else:
+        return cast(datetime.datetime, pendulum.parse(dt))
 
 
 def get_timezones() -> tuple[str, ...]:
-    return pendulum.tz.timezones()
+    return tuple(available_timezones())
 
 
-def create_datetime_instance(v: datetime.datetime) -> DateTime:
-    return DateTime.instance(v)
+def create_datetime_instance(v: datetime.datetime) -> datetime.datetime:
+    if sys.version_info >= (3, 13):
+        if v.tzinfo is None:
+            # Assume UTC if no timezone is provided
+            return v.replace(tzinfo=ZoneInfo("UTC"))
+        else:
+            return v
 
+    return DateTime.instance(v)
 
-def from_format(
-    value: str,
-    fmt: str,
-    tz: str | Timezone = UTC,
-    locale: str | None = None,
-) -> DateTime:
-    return DateTime.instance(pendulum.from_format(value, fmt, tz, locale))
 
+def from_timestamp(ts: float, tz: str | Any = "UTC") -> datetime.datetime:
+    if sys.version_info >= (3, 13):
+        if not isinstance(tz, str):
+            # Handle pendulum edge case
+            tz = tz.name
+        return datetime.datetime.fromtimestamp(ts, ZoneInfo(tz))
 
-def from_timestamp(ts: float, tz: str | pendulum.tz.Timezone = UTC) -> DateTime:
-    return DateTime.instance(pendulum.from_timestamp(ts, tz))
+    return pendulum.from_timestamp(ts, tz)
 
 
-def human_friendly_diff(dt: DateTime | datetime.datetime) -> str:
-    if isinstance(dt, DateTime):
-        return dt.diff_for_humans()
+def human_friendly_diff(
+    dt: datetime.datetime | None, other: datetime.datetime | None = None
+) -> str:
+    if dt is None:
+        return ""
+
+    # Handle naive datetimes consistently across Python versions
+    if dt.tzinfo is None:
+        local_tz = datetime.datetime.now().astimezone().tzinfo
+        dt = dt.replace(tzinfo=local_tz).astimezone(ZoneInfo("UTC"))
+    elif hasattr(dt.tzinfo, "name"):
+        dt = dt.replace(tzinfo=ZoneInfo(getattr(dt.tzinfo, "name")))
+
+    # Handle other parameter if provided
+    if other is not None:
+        if other.tzinfo is None:
+            local_tz = datetime.datetime.now().astimezone().tzinfo
+            other = other.replace(tzinfo=local_tz).astimezone(ZoneInfo("UTC"))
+        elif hasattr(other.tzinfo, "name"):
+            other = other.replace(tzinfo=ZoneInfo(getattr(other.tzinfo, "name")))
+
+    if sys.version_info >= (3, 13):
+        return humanize.naturaltime(dt, when=other)
+
+    return DateTime.instance(dt).diff_for_humans(
+        other=DateTime.instance(other) if other else None
+    )
+
+
+def now(
+    tz: str | Any = "UTC",
+) -> datetime.datetime:
+    if sys.version_info >= (3, 13):
+        from whenever import ZonedDateTime
+
+        if isinstance(getattr(tz, "name", None), str):
+            tz = tz.name
+
+        return ZonedDateTime.now(tz).py_datetime()
     else:
-        return DateTime.instance(dt).diff_for_humans()
-
-
-def now(tz: str | Timezone = UTC) -> DateTime:
-    return DateTime.now(tz)
+        return pendulum.now(tz)
 
 
-def add_years(dt: DateTime, years: int) -> DateTime:
-    return dt.add(years=years)
-
-
-def end_of_period(dt: DateTime, period: str) -> DateTime:
+def end_of_period(dt: datetime.datetime, period: str) -> datetime.datetime:
     """
     Returns the end of the specified unit of time.
 
@@ -91,7 +121,7 @@ def end_of_period(dt: DateTime, period: str) -> DateTime:
         dt: The datetime to get the end of.
         period: The period to get the end of.
                 Valid values: 'second', 'minute', 'hour', 'day',
-                'week', 'month', 'quarter', 'year'
+                'week'
 
     Returns:
         DateTime: A new DateTime representing the end of the specified unit.
@@ -99,27 +129,110 @@ def end_of_period(dt: DateTime, period: str) -> DateTime:
     Raises:
         ValueError: If an invalid unit is specified.
     """
-    return dt.end_of(period)
+    if sys.version_info >= (3, 13):
+        from whenever import Weekday, ZonedDateTime
+
+        if not isinstance(dt.tzinfo, ZoneInfo):
+            zdt = ZonedDateTime.from_py_datetime(
+                dt.replace(tzinfo=ZoneInfo(dt.tzname() or "UTC"))
+            )
+        else:
+            zdt = ZonedDateTime.from_py_datetime(dt)
+        if period == "second":
+            zdt = zdt.replace(nanosecond=999999999)
+        elif period == "minute":
+            zdt = zdt.replace(second=59, nanosecond=999999999)
+        elif period == "hour":
+            zdt = zdt.replace(minute=59, second=59, nanosecond=999999999)
+        elif period == "day":
+            zdt = zdt.replace(hour=23, minute=59, second=59, nanosecond=999999999)
+        elif period == "week":
+            days_till_end_of_week: int = (
+                Weekday.SUNDAY.value - zdt.date().day_of_week().value
+            )
+            zdt = zdt.replace(
+                day=zdt.day + days_till_end_of_week,
+                hour=23,
+                minute=59,
+                second=59,
+                nanosecond=999999999,
+            )
+        else:
+            raise ValueError(f"Invalid period: {period}")
+
+        return zdt.py_datetime()
+    else:
+        return DateTime.instance(dt).end_of(period)
 
 
-def start_of_period(dt: DateTime, period: str) -> DateTime:
+def start_of_day(dt: datetime.datetime | DateTime) -> datetime.datetime:
     """
     Returns the start of the specified unit of time.
 
     Args:
         dt: The datetime to get the start of.
-        period: The period to get the start of.
-                Valid values: 'second', 'minute', 'hour', 'day',
-                'week', 'month', 'quarter', 'year'
 
     Returns:
-        DateTime: A new DateTime representing the start of the specified unit.
+        datetime.datetime: A new datetime.datetime representing the start of the specified unit.
 
     Raises:
         ValueError: If an invalid unit is specified.
     """
-    return dt.start_of(period)
+    if sys.version_info >= (3, 13):
+        from whenever import ZonedDateTime
 
+        if hasattr(dt, "tz"):
+            zdt = ZonedDateTime.from_timestamp(
+                dt.timestamp(), tz=dt.tz.name if dt.tz else "UTC"
+            )
+        else:
+            zdt = ZonedDateTime.from_py_datetime(dt)
 
-def earliest_possible_datetime() -> DateTime:
-    return DateTime.instance(datetime.datetime.min)
+        return zdt.start_of_day().py_datetime()
+    else:
+        return DateTime.instance(dt).start_of("day")
+
+
+def earliest_possible_datetime() -> datetime.datetime:
+    return datetime.datetime.min.replace(tzinfo=ZoneInfo("UTC"))
+
+
+@contextmanager
+def travel_to(dt: Any):
+    if sys.version_info >= (3, 13):
+        with mock.patch("prefect.types._datetime.now", return_value=dt):
+            yield
+
+    else:
+        from pendulum import travel_to
+
+        with travel_to(dt, freeze=True):
+            yield
+
+
+def in_local_tz(dt: datetime.datetime) -> datetime.datetime:
+    if sys.version_info >= (3, 13):
+        from whenever import LocalDateTime, ZonedDateTime
+
+        if dt.tzinfo is None:
+            wdt = LocalDateTime.from_py_datetime(dt)
+        else:
+            if not isinstance(dt.tzinfo, ZoneInfo):
+                if key := getattr(dt.tzinfo, "key", None):
+                    dt = dt.replace(tzinfo=ZoneInfo(key))
+                else:
+                    utc_dt = dt.astimezone(datetime.timezone.utc)
+                    dt = utc_dt.replace(tzinfo=ZoneInfo("UTC"))
+
+            wdt = ZonedDateTime.from_py_datetime(dt).to_system_tz()
+
+        return wdt.py_datetime()
+
+    return DateTime.instance(dt).in_tz(pendulum.tz.local_timezone())
+
+
+def to_datetime_string(dt: datetime.datetime, include_tz: bool = True) -> str:
+    if include_tz:
+        return dt.strftime("%Y-%m-%d %H:%M:%S %Z")
+    else:
+        return dt.strftime("%Y-%m-%d %H:%M:%S")

prefect/utilities/collections.py

@@ -5,7 +5,6 @@ Utilities for extensions of and operations on Python collections.
 import io
 import itertools
 import types
-import warnings
 from collections import OrderedDict
 from collections.abc import (
     Callable,
@@ -509,20 +508,15 @@ def visit_collection(
 
     elif isinstance(expr, pydantic.BaseModel):
         # when extra=allow, fields not in model_fields may be in model_fields_set
-        model_fields = expr.model_fields_set.union(expr.model_fields.keys())
-
-        # We may encounter a deprecated field here, but this isn't the caller's fault
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", category=DeprecationWarning)
-
-            updated_data = {
-                field: visit_nested(getattr(expr, field)) for field in model_fields
-            }
+        original_data = dict(expr)
+        updated_data = {
+            field: visit_nested(value) for field, value in original_data.items()
+        }
 
         if return_data:
             modified = any(
-                getattr(expr, field) is not updated_data[field]
-                for field in model_fields
+                original_data[field] is not updated_data[field]
+                for field in updated_data
             )
             if modified:
                 # Use construct to avoid validation and handle immutability