prefect-client 3.0.0rc14__tar.gz → 3.0.0rc15__tar.gz

{prefect-client-3.0.0rc14/src/prefect_client.egg-info → prefect-client-3.0.0rc15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.0.0rc14
+Version: 3.0.0rc15
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/requirements-client.txt

@@ -35,5 +35,4 @@ toml >= 0.10.0
 typing_extensions >= 4.5.0, < 5.0.0
 ujson >= 5.8.0, < 6.0.0
 uvicorn >=0.14.0, !=0.29.0
-websockets >= 10.4, < 13.0
-wrapt >= 1.16.0
+websockets >= 10.4, < 13.0

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/requirements-dev.txt

@@ -9,7 +9,7 @@ numpy
 pillow
 pre-commit
 pluggy >= 1.4.0
-pytest > 7, < 8 # Datadog's ddtrace does not support pytest 8 yet. See https://github.com/DataDog/dd-trace-py/issues/8220
+pytest > 7, < 9
 pytest-asyncio >= 0.18.2, != 0.22.0, < 0.23.0 # Cannot override event loop in 0.23.0. See https://github.com/pytest-dev/pytest-asyncio/issues/706 for more details.
 pytest-benchmark
 pytest-codspeed

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/_internal/compatibility/deprecated.py

@@ -16,7 +16,6 @@ import warnings
 from typing import Any, Callable, List, Optional, Type, TypeVar
 
 import pendulum
-import wrapt
 from pydantic import BaseModel
 
 from prefect.utilities.callables import get_call_parameters
@@ -273,55 +272,3 @@ def register_renamed_module(old_name: str, new_name: str, start_date: str):
     DEPRECATED_MODULE_ALIASES.append(
         AliasedModuleDefinition(old_name, new_name, callback)
     )
-
-
-class AsyncCompatProxy(wrapt.ObjectProxy):
-    """
-    A proxy object that allows for awaiting a method that is no longer async.
-
-    See https://wrapt.readthedocs.io/en/master/wrappers.html#object-proxy for more
-    """
-
-    def __init__(self, wrapped, class_name: str, method_name: str):
-        super().__init__(wrapped)
-        self._self_class_name = class_name
-        self._self_method_name = method_name
-        self._self_already_awaited = False
-
-    def __await__(self):
-        if not self._self_already_awaited:
-            warnings.warn(
-                (
-                    f"The {self._self_method_name!r} method on {self._self_class_name!r}"
-                    " is no longer async and awaiting it will raise an error after Dec 2024"
-                    " - please remove the `await` keyword."
-                ),
-                DeprecationWarning,
-                stacklevel=2,
-            )
-            self._self_already_awaited = True
-        yield
-        return self.__wrapped__
-
-    def __repr__(self):
-        return repr(self.__wrapped__)
-
-    def __reduce_ex__(self, protocol):
-        return (
-            type(self),
-            (self.__wrapped__,),
-            {"_self_already_awaited": self._self_already_awaited},
-        )
-
-
-def deprecated_async_method(wrapped):
-    """Decorator that wraps a sync method to allow awaiting it even though it is no longer async."""
-
-    @wrapt.decorator
-    def wrapper(wrapped, instance, args, kwargs):
-        result = wrapped(*args, **kwargs)
-        return AsyncCompatProxy(
-            result, class_name=instance.__class__.__name__, method_name=wrapped.__name__
-        )
-
-    return wrapper(wrapped)

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/context.py

@@ -91,11 +91,12 @@ def hydrated_context(
             client = client or get_client(sync_client=True)
             if flow_run_context := serialized_context.get("flow_run_context"):
                 flow = flow_run_context["flow"]
+                task_runner = stack.enter_context(flow.task_runner.duplicate())
                 flow_run_context = FlowRunContext(
                     **flow_run_context,
                     client=client,
                     result_factory=run_coro_as_sync(ResultFactory.from_flow(flow)),
-                    task_runner=flow.task_runner.duplicate(),
+                    task_runner=task_runner,
                     detached=True,
                 )
                 stack.enter_context(flow_run_context)

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/events/clients.py

@@ -15,7 +15,6 @@ from typing import (
 )
 from uuid import UUID
 
-import httpx
 import orjson
 import pendulum
 from cachetools import TTLCache
@@ -29,10 +28,14 @@ from websockets.exceptions import (
     ConnectionClosedOK,
 )
 
-from prefect.client.base import PrefectHttpxAsyncClient
 from prefect.events import Event
 from prefect.logging import get_logger
-from prefect.settings import PREFECT_API_KEY, PREFECT_API_URL, PREFECT_CLOUD_API_URL
+from prefect.settings import (
+    PREFECT_API_KEY,
+    PREFECT_API_URL,
+    PREFECT_CLOUD_API_URL,
+    PREFECT_SERVER_ALLOW_EPHEMERAL_MODE,
+)
 
 if TYPE_CHECKING:
     from prefect.events.filters import EventFilter
@@ -66,7 +69,7 @@ logger = get_logger(__name__)
 
 def get_events_client(
     reconnection_attempts: int = 10,
-    checkpoint_every: int = 20,
+    checkpoint_every: int = 700,
 ) -> "EventsClient":
     api_url = PREFECT_API_URL.value()
     if isinstance(api_url, str) and api_url.startswith(PREFECT_CLOUD_API_URL.value()):
@@ -74,13 +77,25 @@ def get_events_client(
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
         )
-    elif PREFECT_API_URL:
+    elif api_url:
+        return PrefectEventsClient(
+            reconnection_attempts=reconnection_attempts,
+            checkpoint_every=checkpoint_every,
+        )
+    elif PREFECT_SERVER_ALLOW_EPHEMERAL_MODE:
+        from prefect.server.api.server import SubprocessASGIServer
+
+        server = SubprocessASGIServer()
+        server.start()
         return PrefectEventsClient(
+            api_url=server.api_url,
             reconnection_attempts=reconnection_attempts,
             checkpoint_every=checkpoint_every,
         )
     else:
-        return PrefectEphemeralEventsClient()
+        raise ValueError(
+            "No Prefect API URL provided. Please set PREFECT_API_URL to the address of a running Prefect server."
+        )
 
 
 def get_events_subscriber(
@@ -88,20 +103,29 @@ def get_events_subscriber(
     reconnection_attempts: int = 10,
 ) -> "PrefectEventSubscriber":
     api_url = PREFECT_API_URL.value()
-    if not api_url:
-        raise ValueError(
-            "A Prefect server or Prefect Cloud is required to start an event "
-            "subscriber.  Please check the PREFECT_API_URL setting in your profile."
-        )
 
     if isinstance(api_url, str) and api_url.startswith(PREFECT_CLOUD_API_URL.value()):
         return PrefectCloudEventSubscriber(
             filter=filter, reconnection_attempts=reconnection_attempts
         )
-    else:
+    elif api_url:
         return PrefectEventSubscriber(
             filter=filter, reconnection_attempts=reconnection_attempts
         )
+    elif PREFECT_SERVER_ALLOW_EPHEMERAL_MODE:
+        from prefect.server.api.server import SubprocessASGIServer
+
+        server = SubprocessASGIServer()
+        server.start()
+        return PrefectEventSubscriber(
+            api_url=server.api_url,
+            filter=filter,
+            reconnection_attempts=reconnection_attempts,
+        )
+    else:
+        raise ValueError(
+            "No Prefect API URL provided. Please set PREFECT_API_URL to the address of a running Prefect server."
+        )
 
 
 class EventsClient(abc.ABC):
@@ -201,47 +225,6 @@ def _get_api_url_and_key(
     return api_url, api_key
 
 
-class PrefectEphemeralEventsClient(EventsClient):
-    """A Prefect Events client that sends events to an ephemeral Prefect server"""
-
-    def __init__(self):
-        if PREFECT_API_KEY.value():
-            raise ValueError(
-                "PrefectEphemeralEventsClient cannot be used when PREFECT_API_KEY is set."
-                " Please use PrefectEventsClient or PrefectCloudEventsClient instead."
-            )
-        from prefect.server.api.server import create_app
-
-        app = create_app(ephemeral=True)
-
-        self._http_client = PrefectHttpxAsyncClient(
-            transport=httpx.ASGITransport(app=app, raise_app_exceptions=False),
-            base_url="http://ephemeral-prefect/api",
-            enable_csrf_support=False,
-        )
-
-    async def __aenter__(self) -> Self:
-        await super().__aenter__()
-        await self._http_client.__aenter__()
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: Optional[Type[Exception]],
-        exc_val: Optional[Exception],
-        exc_tb: Optional[TracebackType],
-    ) -> None:
-        self._websocket = None
-        await self._http_client.__aexit__(exc_type, exc_val, exc_tb)
-        return await super().__aexit__(exc_type, exc_val, exc_tb)
-
-    async def _emit(self, event: Event) -> None:
-        await self._http_client.post(
-            "/events",
-            json=[event.model_dump(mode="json")],
-        )
-
-
 class PrefectEventsClient(EventsClient):
     """A Prefect Events client that streams events to a Prefect server"""
 
@@ -252,7 +235,7 @@ class PrefectEventsClient(EventsClient):
         self,
         api_url: Optional[str] = None,
         reconnection_attempts: int = 10,
-        checkpoint_every: int = 20,
+        checkpoint_every: int = 700,
     ):
         """
         Args:
@@ -371,7 +354,7 @@ class PrefectCloudEventsClient(PrefectEventsClient):
         api_url: Optional[str] = None,
         api_key: Optional[str] = None,
         reconnection_attempts: int = 10,
-        checkpoint_every: int = 20,
+        checkpoint_every: int = 700,
     ):
         """
         Args:
@@ -435,9 +418,9 @@ class PrefectEventSubscriber:
             reconnection_attempts: When the client is disconnected, how many times
                 the client should attempt to reconnect
         """
+        self._api_key = None
         if not api_url:
             api_url = cast(str, PREFECT_API_URL.value())
-            self._api_key = None
 
         from prefect.events.filters import EventFilter
 

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/events/utilities.py

@@ -8,7 +8,6 @@ from pydantic_extra_types.pendulum_dt import DateTime
 from .clients import (
     AssertingEventsClient,
     PrefectCloudEventsClient,
-    PrefectEphemeralEventsClient,
     PrefectEventsClient,
 )
 from .schemas.events import Event, RelatedResource
@@ -53,7 +52,6 @@ def emit_event(
         AssertingEventsClient,
         PrefectCloudEventsClient,
         PrefectEventsClient,
-        PrefectEphemeralEventsClient,
     ]
     worker_instance = EventsWorker.instance()
 

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/flows.py

@@ -66,6 +66,7 @@ from prefect.exceptions import (
     ObjectNotFound,
     ParameterTypeError,
     ScriptError,
+    TerminationSignal,
     UnspecifiedFlowError,
 )
 from prefect.filesystems import LocalFileSystem, ReadableDeploymentStorage
@@ -946,10 +947,15 @@ class Flow(Generic[P, R]):
             else:
                 raise
 
-        if loop is not None:
-            loop.run_until_complete(runner.start(webserver=webserver))
-        else:
-            asyncio.run(runner.start(webserver=webserver))
+        try:
+            if loop is not None:
+                loop.run_until_complete(runner.start(webserver=webserver))
+            else:
+                asyncio.run(runner.start(webserver=webserver))
+        except (KeyboardInterrupt, TerminationSignal) as exc:
+            logger.info(f"Received {type(exc).__name__}, shutting down...")
+            if loop is not None:
+                loop.stop()
 
     @classmethod
     @sync_compatible

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/futures.py

@@ -10,7 +10,6 @@ from typing import Any, Callable, Generic, List, Optional, Set, Union, cast
 
 from typing_extensions import TypeVar
 
-from prefect._internal.compatibility.deprecated import deprecated_async_method
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import TaskRun
 from prefect.exceptions import ObjectNotFound
@@ -135,7 +134,6 @@ class PrefectConcurrentFuture(PrefectWrappedFuture[R, concurrent.futures.Future]
     when the task run is submitted to a ThreadPoolExecutor.
     """
 
-    @deprecated_async_method
     def wait(self, timeout: Optional[float] = None) -> None:
         try:
             result = self._wrapped_future.result(timeout=timeout)
@@ -144,7 +142,6 @@ class PrefectConcurrentFuture(PrefectWrappedFuture[R, concurrent.futures.Future]
         if isinstance(result, State):
             self._final_state = result
 
-    @deprecated_async_method
     def result(
         self,
         timeout: Optional[float] = None,
@@ -198,7 +195,6 @@ class PrefectDistributedFuture(PrefectFuture[R]):
     done_callbacks: List[Callable[[PrefectFuture], None]] = []
     waiter = None
 
-    @deprecated_async_method
     def wait(self, timeout: Optional[float] = None) -> None:
         return run_coro_as_sync(self.wait_async(timeout=timeout))
 
@@ -235,7 +231,6 @@ class PrefectDistributedFuture(PrefectFuture[R]):
                 self._final_state = task_run.state
             return
 
-    @deprecated_async_method
     def result(
         self,
         timeout: Optional[float] = None,

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/profiles.toml

@@ -10,5 +10,8 @@ PREFECT_SERVER_ALLOW_EPHEMERAL_MODE = "true"
 # You will need to set these values appropriately for your local development environment
 PREFECT_API_URL = "http://127.0.0.1:4200/api"
 
+[profiles.test]
+PREFECT_SERVER_ALLOW_EPHEMERAL_MODE = "true"
+PREFECT_API_DATABASE_CONNECTION_URL = "sqlite+aiosqlite:///:memory:"
 
 [profiles.cloud]

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/runner/storage.py

@@ -280,6 +280,10 @@ class GitRepository:
                 "branch": self._branch,
             }
         }
+        if self._include_submodules:
+            pull_step["prefect.deployments.steps.git_clone"][
+                "include_submodules"
+            ] = self._include_submodules
         if isinstance(self._credentials, Block):
             pull_step["prefect.deployments.steps.git_clone"][
                 "credentials"

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/settings.py

@@ -351,6 +351,7 @@ def warn_on_database_password_value_without_usage(values):
     if (
         value
         and not value.startswith(OBFUSCATED_PREFIX)
+        and values["PREFECT_API_DATABASE_CONNECTION_URL"] is not None
         and (
             "PREFECT_API_DATABASE_PASSWORD"
             not in values["PREFECT_API_DATABASE_CONNECTION_URL"]
@@ -403,7 +404,38 @@ def warn_on_misconfigured_api_url(values):
     return values
 
 
-def default_database_connection_url(settings, value):
+def default_database_connection_url(settings: "Settings", value: Optional[str]):
+    driver = PREFECT_API_DATABASE_DRIVER.value_from(settings)
+    if driver == "postgresql+asyncpg":
+        required = [
+            PREFECT_API_DATABASE_HOST,
+            PREFECT_API_DATABASE_USER,
+            PREFECT_API_DATABASE_NAME,
+            PREFECT_API_DATABASE_PASSWORD,
+        ]
+        missing = [
+            setting.name for setting in required if not setting.value_from(settings)
+        ]
+        if missing:
+            raise ValueError(
+                f"Missing required database connection settings: {', '.join(missing)}"
+            )
+
+        host = PREFECT_API_DATABASE_HOST.value_from(settings)
+        port = PREFECT_API_DATABASE_PORT.value_from(settings) or 5432
+        user = PREFECT_API_DATABASE_USER.value_from(settings)
+        name = PREFECT_API_DATABASE_NAME.value_from(settings)
+        password = PREFECT_API_DATABASE_PASSWORD.value_from(settings)
+
+        return f"{driver}://{user}:{password}@{host}:{port}/{name}"
+
+    elif driver == "sqlite+aiosqlite":
+        path = PREFECT_API_DATABASE_NAME.value_from(settings)
+        if path:
+            return f"{driver}:///{path}"
+    elif driver:
+        raise ValueError(f"Unsupported database driver: {driver}")
+
     templater = template_with_settings(PREFECT_HOME, PREFECT_API_DATABASE_PASSWORD)
 
     # If the user has provided a value, use it
@@ -941,17 +973,6 @@ backend on application startup. If not set, block types must be manually
 registered.
 """
 
-PREFECT_API_DATABASE_PASSWORD = Setting(
-    Optional[str],
-    default=None,
-    is_secret=True,
-)
-"""
-Password to template into the `PREFECT_API_DATABASE_CONNECTION_URL`.
-This is useful if the password must be provided separately from the connection URL.
-To use this setting, you must include it in your connection URL.
-"""
-
 PREFECT_API_DATABASE_CONNECTION_URL = Setting(
     Optional[str],
     default=None,
@@ -981,6 +1002,46 @@ PREFECT_API_DATABASE_CONNECTION_URL='postgresql+asyncpg://postgres:${PREFECT_API
 ```
 """
 
+PREFECT_API_DATABASE_DRIVER = Setting(
+    Optional[Literal["postgresql+asyncpg", "sqlite+aiosqlite"]],
+    default=None,
+)
+"""
+The database driver to use when connecting to the database.
+"""
+
+PREFECT_API_DATABASE_HOST = Setting(Optional[str], default=None)
+"""
+The database server host.
+"""
+
+PREFECT_API_DATABASE_PORT = Setting(Optional[int], default=None)
+"""
+The database server port.
+"""
+
+PREFECT_API_DATABASE_USER = Setting(Optional[str], default=None)
+"""
+The user to use when connecting to the database.
+"""
+
+PREFECT_API_DATABASE_NAME = Setting(Optional[str], default=None)
+"""
+The name of the Prefect database on the remote server, or the path to the database file
+for SQLite.
+"""
+
+PREFECT_API_DATABASE_PASSWORD = Setting(
+    Optional[str],
+    default=None,
+    is_secret=True,
+)
+"""
+Password to template into the `PREFECT_API_DATABASE_CONNECTION_URL`.
+This is useful if the password must be provided separately from the connection URL.
+To use this setting, you must include it in your connection URL.
+"""
+
 PREFECT_API_DATABASE_ECHO = Setting(
     bool,
     default=False,

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/task_engine.py

@@ -409,6 +409,22 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.task_run.state_id = new_state.id
             self.task_run.state_type = new_state.type
             self.task_run.state_name = new_state.name
+
+            if new_state.is_final():
+                if (
+                    isinstance(state.data, BaseResult)
+                    and state.data.has_cached_object()
+                ):
+                    # Avoid fetching the result unless it is cached, otherwise we defeat
+                    # the purpose of disabling `cache_result_in_memory`
+                    result = state.result(raise_on_failure=False, fetch=True)
+                    if inspect.isawaitable(result):
+                        result = run_coro_as_sync(result)
+                else:
+                    result = state.data
+
+                link_state_to_result(state, result)
+
         else:
             try:
                 new_state = propose_state_sync(
@@ -674,6 +690,12 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                                     task_run_name=task_run_name,
                                 )
                             )
+                            # Emit an event to capture that the task run was in the `PENDING` state.
+                            self._last_event = emit_task_run_state_change_event(
+                                task_run=self.task_run,
+                                initial_state=None,
+                                validated_state=self.task_run.state,
+                            )
                     else:
                         if not self.task_run:
                             self.task_run = run_coro_as_sync(
@@ -686,12 +708,12 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                                     extra_task_inputs=dependencies,
                                 )
                             )
-                    # Emit an event to capture that the task run was in the `PENDING` state.
-                    self._last_event = emit_task_run_state_change_event(
-                        task_run=self.task_run,
-                        initial_state=None,
-                        validated_state=self.task_run.state,
-                    )
+                            # Emit an event to capture that the task run was in the `PENDING` state.
+                            self._last_event = emit_task_run_state_change_event(
+                                task_run=self.task_run,
+                                initial_state=None,
+                                validated_state=self.task_run.state,
+                            )
 
                     with self.setup_run_context():
                         # setup_run_context might update the task run name, so log creation here
@@ -966,6 +988,20 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.task_run.state_id = new_state.id
             self.task_run.state_type = new_state.type
             self.task_run.state_name = new_state.name
+
+            if new_state.is_final():
+                if (
+                    isinstance(new_state.data, BaseResult)
+                    and new_state.data.has_cached_object()
+                ):
+                    # Avoid fetching the result unless it is cached, otherwise we defeat
+                    # the purpose of disabling `cache_result_in_memory`
+                    result = await new_state.result(raise_on_failure=False, fetch=True)
+                else:
+                    result = new_state.data
+
+                link_state_to_result(new_state, result)
+
         else:
             try:
                 new_state = await propose_state(
@@ -1222,6 +1258,12 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                                 extra_task_inputs=dependencies,
                                 task_run_name=task_run_name,
                             )
+                            # Emit an event to capture that the task run was in the `PENDING` state.
+                            self._last_event = emit_task_run_state_change_event(
+                                task_run=self.task_run,
+                                initial_state=None,
+                                validated_state=self.task_run.state,
+                            )
                     else:
                         if not self.task_run:
                             self.task_run = await self.task.create_run(
@@ -1232,12 +1274,12 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                                 wait_for=self.wait_for,
                                 extra_task_inputs=dependencies,
                             )
-                    # Emit an event to capture that the task run was in the `PENDING` state.
-                    self._last_event = emit_task_run_state_change_event(
-                        task_run=self.task_run,
-                        initial_state=None,
-                        validated_state=self.task_run.state,
-                    )
+                            # Emit an event to capture that the task run was in the `PENDING` state.
+                            self._last_event = emit_task_run_state_change_event(
+                                task_run=self.task_run,
+                                initial_state=None,
+                                validated_state=self.task_run.state,
+                            )
 
                     async with self.setup_run_context():
                         # setup_run_context might update the task run name, so log creation here

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/task_worker.py

@@ -293,12 +293,15 @@ class TaskWorker:
                     await self._client._client.delete(f"/task_runs/{task_run.id}")
                 return
 
+        initial_state = task_run.state
+
         if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
             new_state = Pending()
             new_state.state_details.deferred = True
             new_state.state_details.task_run_id = task_run.id
             new_state.state_details.flow_run_id = task_run.flow_run_id
             state = new_state
+            task_run.state = state
         else:
             try:
                 new_state = Pending()
@@ -330,7 +333,7 @@ class TaskWorker:
 
         emit_task_run_state_change_event(
             task_run=task_run,
-            initial_state=task_run.state,
+            initial_state=initial_state,
             validated_state=state,
         )
 

{prefect-client-3.0.0rc14 → prefect-client-3.0.0rc15}/src/prefect/tasks.py

@@ -33,9 +33,6 @@ from uuid import UUID, uuid4
 from typing_extensions import Literal, ParamSpec
 
 import prefect.states
-from prefect._internal.compatibility.deprecated import (
-    deprecated_async_method,
-)
 from prefect.cache_policies import DEFAULT, NONE, CachePolicy
 from prefect.client.orchestration import get_client
 from prefect.client.schemas import TaskRun
@@ -1038,7 +1035,6 @@ class Task(Generic[P, R]):
     ) -> State[T]:
         ...
 
-    @deprecated_async_method
     def submit(
         self,
         *args: Any,
@@ -1203,7 +1199,6 @@ class Task(Generic[P, R]):
     ) -> PrefectFutureList[State[T]]:
         ...
 
-    @deprecated_async_method
     def map(
         self,
         *args: Any,
@@ -1455,6 +1450,15 @@ class Task(Generic[P, R]):
             )
         )  # type: ignore
 
+        from prefect.utilities.engine import emit_task_run_state_change_event
+
+        # emit a `SCHEDULED` event for the task run
+        emit_task_run_state_change_event(
+            task_run=task_run,
+            initial_state=None,
+            validated_state=task_run.state,
+        )
+
         if task_run_url := url_for(task_run):
             logger.info(
                 f"Created task run {task_run.name!r}. View it in the UI at {task_run_url!r}"