prefect-client 3.0.0rc9__py3-none-any.whl → 3.0.0rc11__py3-none-any.whl

prefect/futures.py

@@ -1,4 +1,5 @@
 import abc
+import collections
 import concurrent.futures
 import inspect
 import uuid
@@ -256,13 +257,7 @@ class PrefectFutureList(list, Iterator, Generic[F]):
             timeout: The maximum number of seconds to wait for all futures to
                 complete. This method will not raise if the timeout is reached.
         """
-        try:
-            with timeout_context(timeout):
-                for future in self:
-                    future.wait()
-        except TimeoutError:
-            logger.debug("Timed out waiting for all futures to complete.")
-            return
+        wait(self, timeout=timeout)
 
     def result(
         self,
@@ -297,6 +292,57 @@ class PrefectFutureList(list, Iterator, Generic[F]):
             ) from exc
 
 
+DoneAndNotDoneFutures = collections.namedtuple("DoneAndNotDoneFutures", "done not_done")
+
+
+def wait(futures: List[PrefectFuture], timeout=None) -> DoneAndNotDoneFutures:
+    """
+    Wait for the futures in the given sequence to complete.
+
+    Args:
+        futures: The sequence of Futures to wait upon.
+        timeout: The maximum number of seconds to wait. If None, then there
+            is no limit on the wait time.
+
+    Returns:
+        A named 2-tuple of sets. The first set, named 'done', contains the
+        futures that completed (is finished or cancelled) before the wait
+        completed. The second set, named 'not_done', contains uncompleted
+        futures. Duplicate futures given to *futures* are removed and will be
+        returned only once.
+
+    Examples:
+        ```python
+        @task
+        def sleep_task(seconds):
+            sleep(seconds)
+            return 42
+
+        @flow
+        def flow():
+            futures = random_task.map(range(10))
+            done, not_done = wait(futures, timeout=5)
+            print(f"Done: {len(done)}")
+            print(f"Not Done: {len(not_done)}")
+        ```
+    """
+    futures = set(futures)
+    done = {f for f in futures if f._final_state}
+    not_done = futures - done
+    if len(done) == len(futures):
+        return DoneAndNotDoneFutures(done, not_done)
+    try:
+        with timeout_context(timeout):
+            for future in not_done.copy():
+                future.wait()
+                done.add(future)
+                not_done.remove(future)
+            return DoneAndNotDoneFutures(done, not_done)
+    except TimeoutError:
+        logger.debug("Timed out waiting for all futures to complete.")
+        return DoneAndNotDoneFutures(done, not_done)
+
+
 def resolve_futures_to_states(
     expr: Union[PrefectFuture, Any],
 ) -> Union[State, Any]:

prefect/infrastructure/__init__.py

@@ -0,0 +1,6 @@
+"""
+2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
+"""
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)

prefect/infrastructure/base.py

@@ -0,0 +1,6 @@
+"""
+2024-06-27: This surfaces an actionable error message for moved or removed objects in Prefect 3.0 upgrade.
+"""
+from prefect._internal.compatibility.migration import getattr_migration
+
+__getattr__ = getattr_migration(__name__)

prefect/logging/loggers.py

@@ -97,7 +97,7 @@ def get_logger(name: Optional[str] = None) -> logging.Logger:
 
 
 def get_run_logger(
-    context: "RunContext" = None, **kwargs: str
+    context: Optional["RunContext"] = None, **kwargs: str
 ) -> Union[logging.Logger, logging.LoggerAdapter]:
     """
     Get a Prefect logger for the current task run or flow run.

prefect/results.py

@@ -28,7 +28,6 @@ from prefect.client.utilities import inject_client
 from prefect.exceptions import MissingResult, ObjectAlreadyExists
 from prefect.filesystems import (
     LocalFileSystem,
-    ReadableFileSystem,
     WritableFileSystem,
 )
 from prefect.logging import get_logger
@@ -111,22 +110,32 @@ async def _get_or_create_default_storage(block_document_slug: str) -> ResultStor
 
 
 @sync_compatible
-async def get_or_create_default_result_storage() -> ResultStorage:
+async def get_default_result_storage() -> ResultStorage:
     """
     Generate a default file system for result storage.
     """
-    return await _get_or_create_default_storage(
-        PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value()
-    )
+    default_block = PREFECT_DEFAULT_RESULT_STORAGE_BLOCK.value()
+
+    if default_block is not None:
+        return await Block.load(default_block)
+
+    # otherwise, use the local file system
+    basepath = PREFECT_LOCAL_STORAGE_PATH.value()
+    return LocalFileSystem(basepath=basepath)
 
 
 async def get_or_create_default_task_scheduling_storage() -> ResultStorage:
     """
     Generate a default file system for background task parameter/result storage.
     """
-    return await _get_or_create_default_storage(
-        PREFECT_TASK_SCHEDULING_DEFAULT_STORAGE_BLOCK.value()
-    )
+    default_block = PREFECT_TASK_SCHEDULING_DEFAULT_STORAGE_BLOCK.value()
+
+    if default_block is not None:
+        return await Block.load(default_block)
+
+    # otherwise, use the local file system
+    basepath = PREFECT_LOCAL_STORAGE_PATH.value()
+    return LocalFileSystem(basepath=basepath)
 
 
 def get_default_result_serializer() -> ResultSerializer:
@@ -177,9 +186,7 @@ class ResultFactory(BaseModel):
                 kwargs.pop(key)
 
         # Apply defaults
-        kwargs.setdefault(
-            "result_storage", await get_or_create_default_result_storage()
-        )
+        kwargs.setdefault("result_storage", await get_default_result_storage())
         kwargs.setdefault("result_serializer", get_default_result_serializer())
         kwargs.setdefault("persist_result", get_default_persist_setting())
         kwargs.setdefault("cache_result_in_memory", True)
@@ -230,9 +237,7 @@ class ResultFactory(BaseModel):
         """
         Create a new result factory for a task.
         """
-        return await cls._from_task(
-            task, get_or_create_default_result_storage, client=client
-        )
+        return await cls._from_task(task, get_default_result_storage, client=client)
 
     @classmethod
     @inject_client
@@ -268,7 +273,14 @@ class ResultFactory(BaseModel):
             if ctx and ctx.result_factory
             else get_default_result_serializer()
         )
-        persist_result = task.persist_result
+        if task.persist_result is None:
+            persist_result = (
+                ctx.result_factory.persist_result
+                if ctx and ctx.result_factory
+                else get_default_persist_setting()
+            )
+        else:
+            persist_result = task.persist_result
 
         cache_result_in_memory = task.cache_result_in_memory
 
@@ -330,16 +342,7 @@ class ResultFactory(BaseModel):
                 # Avoid saving the block if it already has an identifier assigned
                 storage_block_id = storage_block._block_document_id
             else:
-                if persist_result:
-                    # TODO: Overwrite is true to avoid issues where the save collides with
-                    # a previously saved document with a matching hash
-                    storage_block_id = await storage_block._save(
-                        is_anonymous=True, overwrite=True, client=client
-                    )
-                else:
-                    # a None-type UUID on unpersisted storage should not matter
-                    # since the ID is generated on the server
-                    storage_block_id = None
+                storage_block_id = None
         elif isinstance(result_storage, str):
             storage_block = await Block.load(result_storage, client=client)
             storage_block_id = storage_block._block_document_id
@@ -412,9 +415,6 @@ class ResultFactory(BaseModel):
 
     @sync_compatible
     async def store_parameters(self, identifier: UUID, parameters: Dict[str, Any]):
-        assert (
-            self.storage_block_id is not None
-        ), "Unexpected storage block ID. Was it persisted?"
         data = self.serializer.dumps(parameters)
         blob = PersistedResultBlob(serializer=self.serializer, data=data)
         await self.storage_block.write_path(
@@ -423,9 +423,6 @@ class ResultFactory(BaseModel):
 
     @sync_compatible
     async def read_parameters(self, identifier: UUID) -> Dict[str, Any]:
-        assert (
-            self.storage_block_id is not None
-        ), "Unexpected storage block ID. Was it persisted?"
         blob = PersistedResultBlob.model_validate_json(
             await self.storage_block.read_path(f"parameters/{identifier}")
         )
@@ -435,10 +432,7 @@ class ResultFactory(BaseModel):
 @register_base_type
 class BaseResult(BaseModel, abc.ABC, Generic[R]):
     model_config = ConfigDict(extra="forbid")
-
     type: str
-    artifact_type: Optional[str] = None
-    artifact_description: Optional[str] = None
 
     def __init__(self, **data: Any) -> None:
         type_string = get_dispatch_key(self) if type(self) != BaseResult else "__base__"
@@ -504,11 +498,7 @@ class UnpersistedResult(BaseResult):
         obj: R,
         cache_object: bool = True,
     ) -> "UnpersistedResult[R]":
-        description = f"Unpersisted result of type `{type(obj).__name__}`"
-        result = cls(
-            artifact_type="result",
-            artifact_description=description,
-        )
+        result = cls()
         # Only store the object in local memory, it will not be sent to the API
         if cache_object:
             result._cache_object(obj)
@@ -528,8 +518,8 @@ class PersistedResult(BaseResult):
     type: str = "reference"
 
     serializer_type: str
-    storage_block_id: uuid.UUID
     storage_key: str
+    storage_block_id: Optional[uuid.UUID] = None
     expiration: Optional[DateTime] = None
 
     _should_cache_object: bool = PrivateAttr(default=True)
@@ -547,6 +537,17 @@ class PersistedResult(BaseResult):
         self._storage_block = storage_block
         self._serializer = serializer
 
+    @inject_client
+    async def _get_storage_block(self, client: "PrefectClient") -> WritableFileSystem:
+        if self._storage_block is not None:
+            return self._storage_block
+        elif self.storage_block_id is not None:
+            block_document = await client.read_block_document(self.storage_block_id)
+            self._storage_block = Block._from_block_document(block_document)
+        else:
+            self._storage_block = await get_default_result_storage()
+        return self._storage_block
+
     @sync_compatible
     @inject_client
     async def get(self, client: "PrefectClient") -> R:
@@ -567,12 +568,8 @@ class PersistedResult(BaseResult):
 
     @inject_client
     async def _read_blob(self, client: "PrefectClient") -> "PersistedResultBlob":
-        assert (
-            self.storage_block_id is not None
-        ), "Unexpected storage block ID. Was it persisted?"
-        block_document = await client.read_block_document(self.storage_block_id)
-        storage_block: ReadableFileSystem = Block._from_block_document(block_document)
-        content = await storage_block.read_path(self.storage_key)
+        block = await self._get_storage_block(client=client)
+        content = await block.read_path(self.storage_key)
         blob = PersistedResultBlob.model_validate_json(content)
         return blob
 
@@ -607,10 +604,7 @@ class PersistedResult(BaseResult):
         obj = obj if obj is not NotSet else self._cache
 
         # next, the storage block
-        storage_block = self._storage_block
-        if storage_block is None:
-            block_document = await client.read_block_document(self.storage_block_id)
-            storage_block = Block._from_block_document(block_document)
+        storage_block = await self._get_storage_block(client=client)
 
         # finally, the serializer
         serializer = self._serializer
@@ -673,9 +667,9 @@ class PersistedResult(BaseResult):
         cls: "Type[PersistedResult]",
         obj: R,
         storage_block: WritableFileSystem,
-        storage_block_id: uuid.UUID,
         storage_key_fn: Callable[[], str],
         serializer: Serializer,
+        storage_block_id: Optional[uuid.UUID] = None,
         cache_object: bool = True,
         expiration: Optional[DateTime] = None,
         defer_persistence: bool = False,
@@ -686,31 +680,21 @@ class PersistedResult(BaseResult):
         The object will be serialized and written to the storage block under a unique
         key. It will then be cached on the returned result.
         """
-        assert (
-            storage_block_id is not None
-        ), "Unexpected storage block ID. Was it saved?"
-
         key = storage_key_fn()
         if not isinstance(key, str):
             raise TypeError(
                 f"Expected type 'str' for result storage key; got value {key!r}"
             )
-        description = f"Result of type `{type(obj).__name__}`"
         uri = cls._infer_path(storage_block, key)
-        if uri:
-            if isinstance(storage_block, LocalFileSystem):
-                description += f" persisted to: `{uri}`"
-            else:
-                description += f" persisted to [{uri}]({uri})."
-        else:
-            description += f" persisted with storage block `{storage_block_id}`."
+
+        # in this case we store an absolute path
+        if storage_block_id is None and uri is not None:
+            key = str(uri)
 
         result = cls(
             serializer_type=serializer.type,
             storage_block_id=storage_block_id,
             storage_key=key,
-            artifact_type="result",
-            artifact_description=description,
             expiration=expiration,
         )
 
@@ -787,5 +771,4 @@ class UnknownResult(BaseResult):
                 "Only None is supported."
             )
 
-        description = "Unknown result persisted to Prefect."
-        return cls(value=obj, artifact_type="result", artifact_description=description)
+        return cls(value=obj)

prefect/runner/runner.py

@@ -65,17 +65,13 @@ from prefect.client.schemas.filters import (
     FlowRunFilterStateName,
     FlowRunFilterStateType,
 )
-from prefect.client.schemas.objects import (
-    FlowRun,
-    State,
-    StateType,
-)
+from prefect.client.schemas.objects import Flow as APIFlow
+from prefect.client.schemas.objects import FlowRun, State, StateType
 from prefect.client.schemas.schedules import SCHEDULE_TYPES
-from prefect.deployments.runner import (
-    EntrypointType,
-    RunnerDeployment,
-)
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
+from prefect.events.related import tags_as_related_resources
+from prefect.events.schemas.events import RelatedResource
+from prefect.events.utilities import emit_event
 from prefect.exceptions import Abort, ObjectNotFound
 from prefect.flows import Flow, load_flow_from_flow_run
 from prefect.logging.loggers import PrefectLogAdapter, flow_run_logger, get_logger
@@ -88,6 +84,7 @@ from prefect.settings import (
     get_current_settings,
 )
 from prefect.states import Crashed, Pending, exception_to_failed_state
+from prefect.types.entrypoint import EntrypointType
 from prefect.utilities.asyncutils import (
     asyncnullcontext,
     is_async_fn,
@@ -96,9 +93,12 @@ from prefect.utilities.asyncutils import (
 from prefect.utilities.engine import propose_state
 from prefect.utilities.processutils import _register_signal, run_process
 from prefect.utilities.services import critical_service_loop
+from prefect.utilities.slugify import slugify
 
 if TYPE_CHECKING:
+    from prefect.client.schemas.objects import Deployment
     from prefect.client.types.flexible_schedule_list import FlexibleScheduleList
+    from prefect.deployments.runner import RunnerDeployment
 
 __all__ = ["Runner"]
 
@@ -130,6 +130,7 @@ class Runner:
         Examples:
             Set up a Runner to manage the execute of scheduled flow runs for two flows:
                 ```python
+                import asyncio
                 from prefect import flow, Runner
 
                 @flow
@@ -149,7 +150,7 @@ class Runner:
                     # Run on a cron schedule
                     runner.add_flow(goodbye_flow, schedule={"cron": "0 * * * *"})
 
-                    runner.start()
+                    asyncio.run(runner.start())
                 ```
         """
         if name and ("/" in name or "%" in name):
@@ -166,9 +167,6 @@ class Runner:
         self.query_seconds = query_seconds or PREFECT_RUNNER_POLL_FREQUENCY.value()
         self._prefetch_seconds = prefetch_seconds
 
-        self._runs_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
-        self._loops_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
-
         self._limiter: Optional[anyio.CapacityLimiter] = anyio.CapacityLimiter(
             self.limit
         )
@@ -177,19 +175,20 @@ class Runner:
         self._cancelling_flow_run_ids = set()
         self._scheduled_task_scopes = set()
         self._deployment_ids: Set[UUID] = set()
-        self._flow_run_process_map = dict()
+        self._flow_run_process_map: Dict[UUID, Dict] = dict()
 
         self._tmp_dir: Path = (
             Path(tempfile.gettempdir()) / "runner_storage" / str(uuid4())
         )
         self._storage_objs: List[RunnerStorage] = []
         self._deployment_storage_map: Dict[UUID, RunnerStorage] = {}
-        self._loop = asyncio.get_event_loop()
+
+        self._loop: Optional[asyncio.AbstractEventLoop] = None
 
     @sync_compatible
     async def add_deployment(
         self,
-        deployment: RunnerDeployment,
+        deployment: "RunnerDeployment",
     ) -> UUID:
         """
         Registers the deployment with the Prefect API and will monitor for work once
@@ -324,7 +323,6 @@ class Runner:
 
         sys.exit(0)
 
-    @sync_compatible
     async def start(
         self, run_once: bool = False, webserver: Optional[bool] = None
     ) -> None:
@@ -342,6 +340,7 @@ class Runner:
             Initialize a Runner, add two flows, and serve them by starting the Runner:
 
             ```python
+            import asyncio
             from prefect import flow, Runner
 
             @flow
@@ -361,7 +360,7 @@ class Runner:
                 # Run on a cron schedule
                 runner.add_flow(goodbye_flow, schedule={"cron": "0 * * * *"})
 
-                runner.start()
+                asyncio.run(runner.start())
             ```
         """
         from prefect.runner.server import start_webserver
@@ -695,8 +694,9 @@ class Runner:
         """
         self._logger.info("Pausing all deployments...")
         for deployment_id in self._deployment_ids:
-            self._logger.debug(f"Pausing deployment '{deployment_id}'")
             await self._client.set_deployment_paused_state(deployment_id, True)
+            self._logger.debug(f"Paused deployment '{deployment_id}'")
+
         self._logger.info("All deployments have been paused!")
 
     async def _get_and_submit_flow_runs(self):
@@ -818,8 +818,71 @@ class Runner:
                     "message": state_msg or "Flow run was cancelled successfully."
                 },
             )
+            try:
+                deployment = await self._client.read_deployment(flow_run.deployment_id)
+            except ObjectNotFound:
+                deployment = None
+            try:
+                flow = await self._client.read_flow(flow_run.flow_id)
+            except ObjectNotFound:
+                flow = None
+            self._emit_flow_run_cancelled_event(
+                flow_run=flow_run, flow=flow, deployment=deployment
+            )
             run_logger.info(f"Cancelled flow run '{flow_run.name}'!")
 
+    def _event_resource(self):
+        from prefect import __version__
+
+        return {
+            "prefect.resource.id": f"prefect.runner.{slugify(self.name)}",
+            "prefect.resource.name": self.name,
+            "prefect.version": __version__,
+        }
+
+    def _emit_flow_run_cancelled_event(
+        self,
+        flow_run: "FlowRun",
+        flow: "Optional[APIFlow]",
+        deployment: "Optional[Deployment]",
+    ):
+        related = []
+        tags = []
+        if deployment:
+            related.append(
+                {
+                    "prefect.resource.id": f"prefect.deployment.{deployment.id}",
+                    "prefect.resource.role": "deployment",
+                    "prefect.resource.name": deployment.name,
+                }
+            )
+            tags.extend(deployment.tags)
+        if flow:
+            related.append(
+                {
+                    "prefect.resource.id": f"prefect.flow.{flow.id}",
+                    "prefect.resource.role": "flow",
+                    "prefect.resource.name": flow.name,
+                }
+            )
+        related.append(
+            {
+                "prefect.resource.id": f"prefect.flow-run.{flow_run.id}",
+                "prefect.resource.role": "flow-run",
+                "prefect.resource.name": flow_run.name,
+            }
+        )
+        tags.extend(flow_run.tags)
+
+        related = [RelatedResource.model_validate(r) for r in related]
+        related += tags_as_related_resources(set(tags))
+
+        emit_event(
+            event="prefect.runner.cancelled-flow-run",
+            resource=self._event_resource(),
+            related=related,
+        )
+
     async def _get_scheduled_flow_runs(
         self,
     ) -> List["FlowRun"]:
@@ -956,7 +1019,7 @@ class Runner:
             # If the run is not ready to submit, release the concurrency slot
             self._release_limit_slot(flow_run.id)
 
-        self._submitting_flow_run_ids.remove(flow_run.id)
+        self._submitting_flow_run_ids.discard(flow_run.id)
 
     async def _submit_run_and_capture_errors(
         self,
@@ -1163,6 +1226,16 @@ class Runner:
         self._logger.debug("Starting runner...")
         self._client = get_client()
         self._tmp_dir.mkdir(parents=True)
+
+        if not hasattr(self, "_loop") or not self._loop:
+            self._loop = asyncio.get_event_loop()
+
+        if not hasattr(self, "_runs_task_group") or not self._runs_task_group:
+            self._runs_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
+
+        if not hasattr(self, "_loops_task_group") or not self._loops_task_group:
+            self._loops_task_group: anyio.abc.TaskGroup = anyio.create_task_group()
+
         await self._client.__aenter__()
         await self._runs_task_group.__aenter__()
 

prefect/runner/server.py

@@ -16,7 +16,6 @@ from prefect.runner.utils import (
     inject_schemas_into_openapi,
 )
 from prefect.settings import (
-    PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS,
     PREFECT_RUNNER_POLL_FREQUENCY,
     PREFECT_RUNNER_SERVER_HOST,
     PREFECT_RUNNER_SERVER_LOG_LEVEL,
@@ -202,7 +201,7 @@ def _build_generic_endpoint_for_flows(
 
         try:
             flow = load_flow_from_entrypoint(body.entrypoint)
-        except (MissingFlowError, ScriptError, ModuleNotFoundError):
+        except (FileNotFoundError, MissingFlowError, ScriptError, ModuleNotFoundError):
             return JSONResponse(
                 status_code=status.HTTP_404_NOT_FOUND,
                 content={"message": "Flow not found"},
@@ -261,29 +260,28 @@ async def build_server(runner: "Runner") -> FastAPI:
     router.add_api_route("/shutdown", shutdown(runner=runner), methods=["POST"])
     webserver.include_router(router)
 
-    if PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS.value():
-        deployments_router, deployment_schemas = await get_deployment_router(runner)
-        webserver.include_router(deployments_router)
-
-        subflow_schemas = await get_subflow_schemas(runner)
-        webserver.add_api_route(
-            "/flow/run",
-            _build_generic_endpoint_for_flows(runner=runner, schemas=subflow_schemas),
-            methods=["POST"],
-            name="Run flow in background",
-            description="Trigger any flow run as a background task on the runner.",
-            summary="Run flow",
-        )
-
-        def customize_openapi():
-            if webserver.openapi_schema:
-                return webserver.openapi_schema
+    deployments_router, deployment_schemas = await get_deployment_router(runner)
+    webserver.include_router(deployments_router)
+
+    subflow_schemas = await get_subflow_schemas(runner)
+    webserver.add_api_route(
+        "/flow/run",
+        _build_generic_endpoint_for_flows(runner=runner, schemas=subflow_schemas),
+        methods=["POST"],
+        name="Run flow in background",
+        description="Trigger any flow run as a background task on the runner.",
+        summary="Run flow",
+    )
 
-            openapi_schema = inject_schemas_into_openapi(webserver, deployment_schemas)
-            webserver.openapi_schema = openapi_schema
+    def customize_openapi():
+        if webserver.openapi_schema:
             return webserver.openapi_schema
 
-        webserver.openapi = customize_openapi
+        openapi_schema = inject_schemas_into_openapi(webserver, deployment_schemas)
+        webserver.openapi_schema = openapi_schema
+        return webserver.openapi_schema
+
+    webserver.openapi = customize_openapi
 
     return webserver
 

prefect/runner/submit.py

@@ -14,7 +14,6 @@ from prefect.context import FlowRunContext
 from prefect.flows import Flow
 from prefect.logging import get_logger
 from prefect.settings import (
-    PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS,
     PREFECT_RUNNER_PROCESS_LIMIT,
     PREFECT_RUNNER_SERVER_HOST,
     PREFECT_RUNNER_SERVER_PORT,
@@ -131,13 +130,6 @@ async def submit_to_runner(
             "The `submit_to_runner` utility only supports submitting flows and tasks."
         )
 
-    if not PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS.value():
-        raise ValueError(
-            "The `submit_to_runner` utility requires the `Runner` webserver to be"
-            " running and built with extra endpoints enabled. To enable this, set the"
-            " `PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS` setting to `True`."
-        )
-
     parameters = parameters or {}
     if isinstance(parameters, List):
         return_single = False