prefect-client 3.0.0rc8__tar.gz → 3.0.0rc9__tar.gz

{prefect-client-3.0.0rc8/src/prefect_client.egg-info → prefect-client-3.0.0rc9}/PKG-INFO

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

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/requirements-client.txt

@@ -35,3 +35,4 @@ 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

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/requirements-dev.txt

@@ -4,11 +4,6 @@ codespell>=2.2.6
 ddtrace
 ipython
 jinja2
-mkdocs
-mkdocs-gen-files
-mkdocs-material
-mkdocstrings-python
-mike
 moto >= 5
 mypy >= 1.9.0
 numpy
@@ -23,7 +18,6 @@ pytest-env
 pytest-flakefinder
 pytest-timeout
 pytest-xdist >= 3.6.1
-pytkdocs >= 0.14.2
 pyyaml
 redis>=5.0.1
 setuptools
@@ -40,3 +34,4 @@ types-PyYAML
 mkdocs
 mkdocs-material
 mkdocstrings[python]
+mkdocs-gen-files

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/_internal/compatibility/deprecated.py

@@ -16,6 +16,7 @@ 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
@@ -272,3 +273,55 @@ 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.0rc8 → prefect-client-3.0.0rc9}/src/prefect/_internal/compatibility/migration.py

@@ -27,15 +27,17 @@ MOVED_IN_V3 = {
     "prefect.engine:resume_flow_run": "prefect.flow_runs:resume_flow_run",
     "prefect.engine:suspend_flow_run": "prefect.flow_runs:suspend_flow_run",
     "prefect.engine:_in_process_pause": "prefect.flow_runs:_in_process_pause",
+    "prefect.client:get_client": "prefect.client.orchestration:get_client",
 }
 
 REMOVED_IN_V3 = {
-    "prefect.deployments.deployments:Deployment": "Use 'flow.serve()', `flow.deploy()`, or `prefect deploy` instead.",
-    "prefect.deployments:Deployment": "Use 'flow.serve()', `flow.deploy()`, or `prefect deploy` instead.",
-    "prefect.filesystems:GCS": "Use 'prefect_gcp' instead.",
-    "prefect.filesystems:Azure": "Use 'prefect_azure' instead.",
-    "prefect.filesystems:S3": "Use 'prefect_aws' instead.",
-    "prefect.engine:_out_of_process_pause": "Use 'prefect.flow_runs.pause_flow_run' instead.",
+    "prefect.client.schemas.objects:MinimalDeploymentSchedule": "Use `prefect.client.schemas.actions.DeploymentScheduleCreate` instead.",
+    "prefect.deployments.deployments:Deployment": "Use `flow.serve()`, `flow.deploy()`, or `prefect deploy` instead.",
+    "prefect.deployments:Deployment": "Use `flow.serve()`, `flow.deploy()`, or `prefect deploy` instead.",
+    "prefect.filesystems:GCS": "Use `prefect_gcp` instead.",
+    "prefect.filesystems:Azure": "Use `prefect_azure` instead.",
+    "prefect.filesystems:S3": "Use `prefect_aws` instead.",
+    "prefect.engine:_out_of_process_pause": "Use `prefect.flow_runs.pause_flow_run` instead.",
 }
 
 # IMPORTANT FOR USAGE: When adding new modules to MOVED_IN_V3 or REMOVED_IN_V3, include the following lines at the bottom of that module:

prefect-client-3.0.0rc9/src/prefect/_internal/integrations.py

@@ -0,0 +1,7 @@
+KNOWN_EXTRAS_FOR_PACKAGES = {
+    "prefect-kubernetes": "prefect[kubernetes]",
+    "prefect-aws": "prefect[aws]",
+    "prefect-gcp": "prefect[gcp]",
+    "prefect-azure": "prefect[azure]",
+    "prefect-docker": "prefect[docker]",
+}

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/blocks/core.py

@@ -798,7 +798,7 @@ class Block(BaseModel, ABC):
         name: str,
         validate: bool = True,
         client: Optional["PrefectClient"] = None,
-    ):
+    ) -> "Self":
         """
         Retrieves data from the block document with the given name for the block type
         that corresponds with the current class and returns an instantiated version of

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/client/__init__.py

@@ -15,3 +15,7 @@ $ python -m asyncio
 ```
 </div>
 """
+
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/client/schemas/objects.py

@@ -28,6 +28,7 @@ from pydantic import (
 from pydantic_extra_types.pendulum_dt import DateTime
 from typing_extensions import Literal, Self
 
+from prefect._internal.compatibility.migration import getattr_migration
 from prefect._internal.schemas.bases import ObjectBaseModel, PrefectBaseModel
 from prefect._internal.schemas.fields import CreatedBy, UpdatedBy
 from prefect._internal.schemas.validators import (
@@ -1604,3 +1605,6 @@ class CsrfToken(ObjectBaseModel):
     expiration: datetime.datetime = Field(
         default=..., description="The expiration time of the CSRF token"
     )
+
+
+__getattr__ = getattr_migration(__name__)

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/client/utilities.py

@@ -78,10 +78,10 @@ def client_injector(
 
 
 def inject_client(
-    fn: Callable[P, Coroutine[Any, Any, Any]],
-) -> Callable[P, Coroutine[Any, Any, Any]]:
+    fn: Callable[P, Coroutine[Any, Any, R]],
+) -> Callable[P, Coroutine[Any, Any, R]]:
     """
-    Simple helper to provide a context managed client to a asynchronous function.
+    Simple helper to provide a context managed client to an asynchronous function.
 
     The decorated function _must_ take a `client` kwarg and if a client is passed when
     called it will be used instead of creating a new one, but it will not be context
@@ -89,7 +89,7 @@ def inject_client(
     """
 
     @wraps(fn)
-    async def with_injected_client(*args: P.args, **kwargs: P.kwargs) -> Any:
+    async def with_injected_client(*args: P.args, **kwargs: P.kwargs) -> R:
         client = cast(Optional["PrefectClient"], kwargs.pop("client", None))
         client, inferred = get_or_create_client(client)
         if not inferred:

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/deployments/steps/core.py

@@ -22,6 +22,7 @@ from typing import Any, Dict, List, Optional, Tuple, Union
 
 from prefect._internal.compatibility.deprecated import PrefectDeprecationWarning
 from prefect._internal.concurrency.api import Call, from_async
+from prefect._internal.integrations import KNOWN_EXTRAS_FOR_PACKAGES
 from prefect.logging.loggers import get_logger
 from prefect.settings import PREFECT_DEBUG_MODE
 from prefect.utilities.importtools import import_object
@@ -84,6 +85,11 @@ def _get_function_for_step(
             raise
 
     try:
+        packages = [
+            KNOWN_EXTRAS_FOR_PACKAGES.get(package, package)
+            for package in packages
+            if package
+        ]
         subprocess.check_call([sys.executable, "-m", "pip", "install", *packages])
     except subprocess.CalledProcessError:
         get_logger("deployments.steps.core").warning(

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/engine.py

@@ -31,16 +31,16 @@ if __name__ == "__main__":
     try:
         from prefect.flow_engine import (
             load_flow_and_flow_run,
-            run_flow_async,
-            run_flow_sync,
+            run_flow,
         )
 
         flow_run, flow = load_flow_and_flow_run(flow_run_id=flow_run_id)
         # run the flow
         if flow.isasync:
-            run_coro_as_sync(run_flow_async(flow, flow_run=flow_run))
+            run_coro_as_sync(run_flow(flow, flow_run=flow_run))
         else:
-            run_flow_sync(flow, flow_run=flow_run)
+            run_flow(flow, flow_run=flow_run)
+
     except Abort as exc:
         engine_logger.info(
             f"Engine execution of flow run '{flow_run_id}' aborted by orchestrator:"

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/flow_engine.py

@@ -51,7 +51,11 @@ from prefect.states import (
     return_value_to_state,
 )
 from prefect.utilities.asyncutils import run_coro_as_sync
-from prefect.utilities.callables import call_with_parameters, parameters_to_args_kwargs
+from prefect.utilities.callables import (
+    call_with_parameters,
+    get_call_parameters,
+    parameters_to_args_kwargs,
+)
 from prefect.utilities.collections import visit_collection
 from prefect.utilities.engine import (
     _get_hook_name,
@@ -595,10 +599,11 @@ def run_flow_sync(
     wait_for: Optional[Iterable[PrefectFuture]] = None,
     return_type: Literal["state", "result"] = "result",
 ) -> Union[R, State, None]:
-    parameters = flow_run.parameters if flow_run else parameters
-
     engine = FlowRunEngine[P, R](
-        flow=flow, parameters=parameters, flow_run=flow_run, wait_for=wait_for
+        flow=flow,
+        parameters=parameters,
+        flow_run=flow_run,
+        wait_for=wait_for,
     )
 
     with engine.start():
@@ -616,8 +621,6 @@ async def run_flow_async(
     wait_for: Optional[Iterable[PrefectFuture]] = None,
     return_type: Literal["state", "result"] = "result",
 ) -> Union[R, State, None]:
-    parameters = flow_run.parameters if flow_run else parameters
-
     engine = FlowRunEngine[P, R](
         flow=flow, parameters=parameters, flow_run=flow_run, wait_for=wait_for
     )
@@ -714,10 +717,13 @@ def run_flow(
     kwargs = dict(
         flow=flow,
         flow_run=flow_run,
-        parameters=parameters,
+        parameters=_flow_parameters(
+            flow=flow, flow_run=flow_run, parameters=parameters
+        ),
         wait_for=wait_for,
         return_type=return_type,
     )
+
     if flow.isasync and flow.isgenerator:
         return run_generator_flow_async(**kwargs)
     elif flow.isgenerator:
@@ -726,3 +732,20 @@ def run_flow(
         return run_flow_async(**kwargs)
     else:
         return run_flow_sync(**kwargs)
+
+
+def _flow_parameters(
+    flow: Flow[P, R], flow_run: Optional[FlowRun], parameters: Optional[Dict[str, Any]]
+) -> Dict[str, Any]:
+    if parameters:
+        # This path is taken when a flow is being called directly with
+        # parameters, in that case just return the parameters as-is.
+        return parameters
+
+    # Otherwise the flow is being executed indirectly and we may need to grab
+    # the parameters from the flow run. We also need to resolve any default
+    # parameters that are defined on the flow function itself.
+
+    parameters = flow_run.parameters if flow_run else {}
+    call_args, call_kwargs = parameters_to_args_kwargs(flow.fn, parameters)
+    return get_call_parameters(flow.fn, call_args, call_kwargs)

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/flow_runs.py

@@ -340,7 +340,7 @@ async def suspend_flow_run(
     already started will run until completion. When resumed, the flow run will
     be rescheduled to finish execution. In order suspend a flow run in this
     way, the flow needs to have an associated deployment and results need to be
-    configured with the `persist_results` option.
+    configured with the `persist_result` option.
 
     Args:
         flow_run_id: a flow run id. If supplied, this function will attempt to

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/flows.py

@@ -53,8 +53,6 @@ from prefect.client.schemas.objects import Flow as FlowSchema
 from prefect.client.schemas.objects import FlowRun
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
 from prefect.client.utilities import client_injector
-from prefect.deployments.runner import deploy
-from prefect.deployments.steps.core import run_steps
 from prefect.docker.docker_image import DockerImage
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
@@ -69,12 +67,6 @@ from prefect.futures import PrefectFuture
 from prefect.logging import get_logger
 from prefect.logging.loggers import flow_run_logger
 from prefect.results import ResultSerializer, ResultStorage
-from prefect.runner.storage import (
-    BlockStorageAdapter,
-    LocalStorage,
-    RunnerStorage,
-    create_storage_from_source,
-)
 from prefect.settings import (
     PREFECT_DEFAULT_WORK_POOL_NAME,
     PREFECT_FLOW_DEFAULT_RETRIES,
@@ -120,6 +112,7 @@ if TYPE_CHECKING:
     from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
     from prefect.deployments.runner import RunnerDeployment
     from prefect.flows import FlowRun
+    from prefect.runner.storage import RunnerStorage
 
 
 class Flow(Generic[P, R]):
@@ -353,7 +346,7 @@ class Flow(Generic[P, R]):
         self.on_running_hooks = on_running or []
 
         # Used for flows loaded from remote storage
-        self._storage: Optional[RunnerStorage] = None
+        self._storage: Optional["RunnerStorage"] = None
         self._entrypoint: Optional[str] = None
 
         module = fn.__module__
@@ -919,7 +912,7 @@ class Flow(Generic[P, R]):
     @sync_compatible
     async def from_source(
         cls: Type[F],
-        source: Union[str, RunnerStorage, ReadableDeploymentStorage],
+        source: Union[str, "RunnerStorage", ReadableDeploymentStorage],
         entrypoint: str,
     ) -> F:
         """
@@ -968,6 +961,14 @@ class Flow(Generic[P, R]):
             my_flow()
             ```
         """
+
+        from prefect.runner.storage import (
+            BlockStorageAdapter,
+            LocalStorage,
+            RunnerStorage,
+            create_storage_from_source,
+        )
+
         if isinstance(source, str):
             storage = create_storage_from_source(source)
         elif isinstance(source, RunnerStorage):
@@ -1145,7 +1146,9 @@ class Flow(Generic[P, R]):
             entrypoint_type=entrypoint_type,
         )
 
-        deployment_ids = await deploy(
+        from prefect.deployments import runner
+
+        deployment_ids = await runner.deploy(
             deployment,
             work_pool_name=work_pool_name,
             image=image,
@@ -1833,6 +1836,9 @@ async def load_flow_from_flow_run(
         run_logger.debug(
             f"Running {len(deployment.pull_steps)} deployment pull step(s)"
         )
+
+        from prefect.deployments.steps.core import run_steps
+
         output = await run_steps(deployment.pull_steps)
         if output.get("directory"):
             run_logger.debug(f"Changing working directory to {output['directory']!r}")

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/futures.py

@@ -8,6 +8,7 @@ from typing import Any, 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
@@ -111,6 +112,7 @@ 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)
@@ -119,6 +121,7 @@ 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,
@@ -168,6 +171,7 @@ class PrefectDistributedFuture(PrefectFuture[R]):
     any task run scheduled in Prefect's API.
     """
 
+    @deprecated_async_method
     def wait(self, timeout: Optional[float] = None) -> None:
         return run_coro_as_sync(self.wait_async(timeout=timeout))
 
@@ -204,6 +208,7 @@ 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.0rc8 → prefect-client-3.0.0rc9}/src/prefect/logging/loggers.py

@@ -115,7 +115,7 @@ def get_run_logger(
             addition to the run metadata
 
     Raises:
-        RuntimeError: If no context can be found
+        MissingContextError: If no context can be found
     """
     # Check for existing contexts
     task_run_context = prefect.context.TaskRunContext.get()

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/results.py

@@ -1,4 +1,5 @@
 import abc
+import inspect
 import uuid
 from functools import partial
 from typing import (
@@ -620,9 +621,42 @@ class PersistedResult(BaseResult):
         try:
             data = serializer.dumps(obj)
         except Exception as exc:
+            extra_info = (
+                'You can try a different serializer (e.g. result_serializer="json") '
+                "or disabling persistence (persist_result=False) for this flow or task."
+            )
+            # check if this is a known issue with cloudpickle and pydantic
+            # and add extra information to help the user recover
+
+            if (
+                isinstance(exc, TypeError)
+                and isinstance(obj, BaseModel)
+                and str(exc).startswith("cannot pickle")
+            ):
+                try:
+                    from IPython import get_ipython
+
+                    if get_ipython() is not None:
+                        extra_info = inspect.cleandoc(
+                            """
+                            This is a known issue in Pydantic that prevents
+                            locally-defined (non-imported) models from being
+                            serialized by cloudpickle in IPython/Jupyter
+                            environments. Please see
+                            https://github.com/pydantic/pydantic/issues/8232 for
+                            more information. To fix the issue, either: (1) move
+                            your Pydantic class definition to an importable
+                            location, (2) use the JSON serializer for your flow
+                            or task (`result_serializer="json"`), or (3)
+                            disable result persistence for your flow or task
+                            (`persist_result=False`).
+                            """
+                        ).replace("\n", " ")
+                except ImportError:
+                    pass
             raise ValueError(
                 f"Failed to serialize object of type {type(obj).__name__!r} with "
-                f"serializer {serializer.type!r}."
+                f"serializer {serializer.type!r}. {extra_info}"
             ) from exc
         blob = PersistedResultBlob(
             serializer=serializer, data=data, expiration=self.expiration

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/settings.py

@@ -734,7 +734,7 @@ PREFECT_RESULTS_DEFAULT_SERIALIZER = Setting(
 
 PREFECT_RESULTS_PERSIST_BY_DEFAULT = Setting(
     bool,
-    default=True,
+    default=False,
 )
 """
 The default setting for persisting results when not otherwise specified. If enabled,

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/task_engine.py

@@ -602,6 +602,7 @@ class TaskRunEngine(Generic[P, R]):
             key=self.compute_transaction_key(),
             store=ResultFactoryStore(result_factory=result_factory),
             overwrite=overwrite,
+            logger=self.logger,
         ) as txn:
             yield txn
 

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/task_worker.py

@@ -7,7 +7,7 @@ import sys
 from concurrent.futures import ThreadPoolExecutor
 from contextlib import AsyncExitStack
 from contextvars import copy_context
-from typing import List, Optional
+from typing import Optional
 from uuid import UUID
 
 import anyio
@@ -20,6 +20,7 @@ from websockets.exceptions import InvalidStatusCode
 
 from prefect import Task
 from prefect._internal.concurrency.api import create_call, from_sync
+from prefect.cache_policies import DEFAULT, NONE
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.objects import TaskRun
 from prefect.client.subscriptions import Subscription
@@ -32,6 +33,7 @@ from prefect.settings import (
 )
 from prefect.states import Pending
 from prefect.task_engine import run_task_async, run_task_sync
+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, propose_state
 from prefect.utilities.processutils import _register_signal
@@ -76,7 +78,16 @@ class TaskWorker:
         *tasks: Task,
         limit: Optional[int] = 10,
     ):
-        self.tasks: List[Task] = list(tasks)
+        self.tasks = []
+        for t in tasks:
+            if isinstance(t, Task):
+                if t.cache_policy in [None, NONE, NotSet]:
+                    self.tasks.append(
+                        t.with_options(persist_result=True, cache_policy=DEFAULT)
+                    )
+                else:
+                    self.tasks.append(t.with_options(persist_result=True))
+
         self.task_keys = set(t.task_key for t in tasks if isinstance(t, Task))
 
         self._started_at: Optional[pendulum.DateTime] = None

{prefect-client-3.0.0rc8 → prefect-client-3.0.0rc9}/src/prefect/tasks.py

@@ -33,6 +33,9 @@ from uuid import UUID, uuid4
 
 from typing_extensions import Literal, ParamSpec
 
+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
@@ -477,7 +480,7 @@ class Task(Generic[P, R]):
         cache_key_fn: Optional[
             Callable[["TaskRunContext", Dict[str, Any]], Optional[str]]
         ] = None,
-        task_run_name: Optional[Union[Callable[[], str], str]] = None,
+        task_run_name: Optional[Union[Callable[[], str], str, Type[NotSet]]] = NotSet,
         cache_expiration: Optional[datetime.timedelta] = None,
         retries: Union[int, Type[NotSet]] = NotSet,
         retry_delay_seconds: Union[
@@ -591,7 +594,9 @@ class Task(Generic[P, R]):
             else self.cache_policy,
             cache_key_fn=cache_key_fn or self.cache_key_fn,
             cache_expiration=cache_expiration or self.cache_expiration,
-            task_run_name=task_run_name,
+            task_run_name=task_run_name
+            if task_run_name is not NotSet
+            else self.task_run_name,
             retries=retries if retries is not NotSet else self.retries,
             retry_delay_seconds=(
                 retry_delay_seconds
@@ -869,6 +874,7 @@ class Task(Generic[P, R]):
     ) -> State[T]:
         ...
 
+    @deprecated_async_method
     def submit(
         self,
         *args: Any,
@@ -1033,6 +1039,7 @@ class Task(Generic[P, R]):
     ) -> PrefectFutureList[State[T]]:
         ...
 
+    @deprecated_async_method
     def map(
         self,
         *args: Any,