prefect-client 2.17.1__py3-none-any.whl → 2.18.1__py3-none-any.whl

prefect/results.py

@@ -16,17 +16,10 @@ from typing import (
 )
 from uuid import UUID
 
-from typing_extensions import Self
+from typing_extensions import ParamSpec, Self
 
 import prefect
 from prefect._internal.pydantic import HAS_PYDANTIC_V2
-
-if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-
-else:
-    import pydantic
-
 from prefect.blocks.core import Block
 from prefect.client.utilities import inject_client
 from prefect.exceptions import MissingResult
@@ -46,7 +39,14 @@ from prefect.settings import (
 )
 from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import sync_compatible
-from prefect.utilities.pydantic import add_type_dispatch
+from prefect.utilities.pydantic import get_dispatch_key, lookup_type, register_base_type
+
+if HAS_PYDANTIC_V2:
+    import pydantic.v1 as pydantic
+
+else:
+    import pydantic
+
 
 if TYPE_CHECKING:
     from prefect import Flow, Task
@@ -63,6 +63,7 @@ def DEFAULT_STORAGE_KEY_FN():
 
 
 logger = get_logger("results")
+P = ParamSpec("P")
 R = TypeVar("R")
 
 
@@ -286,7 +287,7 @@ class ResultFactory(pydantic.BaseModel):
     @classmethod
     @inject_client
     async def from_autonomous_task(
-        cls: Type[Self], task: "Task", client: "PrefectClient" = None
+        cls: Type[Self], task: "Task[P, R]", client: "PrefectClient" = None
     ) -> Self:
         """
         Create a new result factory for an autonomous task.
@@ -480,12 +481,27 @@ class ResultFactory(pydantic.BaseModel):
         return self.serializer.loads(blob.data)
 
 
-@add_type_dispatch
+@register_base_type
 class BaseResult(pydantic.BaseModel, abc.ABC, Generic[R]):
     type: str
     artifact_type: Optional[str]
     artifact_description: Optional[str]
 
+    def __init__(self, **data: Any) -> None:
+        type_string = get_dispatch_key(self) if type(self) != BaseResult else "__base__"
+        data.setdefault("type", type_string)
+        super().__init__(**data)
+
+    def __new__(cls: Type[Self], **kwargs) -> Self:
+        if "type" in kwargs:
+            try:
+                subcls = lookup_type(cls, dispatch_key=kwargs["type"])
+            except KeyError as exc:
+                raise pydantic.ValidationError(errors=[exc], model=cls)
+            return super().__new__(subcls)
+        else:
+            return super().__new__(cls)
+
     _cache: Any = pydantic.PrivateAttr(NotSet)
 
     def _cache_object(self, obj: Any) -> None:
@@ -511,6 +527,10 @@ class BaseResult(pydantic.BaseModel, abc.ABC, Generic[R]):
     class Config:
         extra = "forbid"
 
+    @classmethod
+    def __dispatch_key__(cls, **kwargs):
+        return cls.__fields__.get("type").get_default()
+
 
 class UnpersistedResult(BaseResult):
     """
@@ -713,7 +733,7 @@ class PersistedResultBlob(pydantic.BaseModel):
 
 class UnknownResult(BaseResult):
     """
-    Result type for unknown results. Typipcally used to represent the result
+    Result type for unknown results. Typically used to represent the result
     of tasks that were forced from a failure state into a completed state.
 
     The value for this result is always None and is not persisted to external

prefect/runner/runner.py

@@ -29,6 +29,7 @@ Example:
     ```
 
 """
+
 import asyncio
 import datetime
 import inspect
@@ -80,7 +81,7 @@ from prefect.deployments.runner import (
 )
 from prefect.deployments.schedules import FlexibleScheduleList
 from prefect.engine import propose_state
-from prefect.events import DeploymentTriggerTypes
+from prefect.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.exceptions import (
     Abort,
 )
@@ -232,7 +233,7 @@ class Runner:
         schedule: Optional[SCHEDULE_TYPES] = None,
         is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
-        triggers: Optional[List[DeploymentTriggerTypes]] = None,
+        triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
         tags: Optional[List[str]] = None,
         version: Optional[str] = None,

prefect/serializers.py

@@ -13,9 +13,10 @@ bytes to an object respectively.
 
 import abc
 import base64
-from typing import Any, Dict, Generic, Optional, TypeVar
+from typing import Any, Dict, Generic, Optional, Type, TypeVar
+
+from typing_extensions import Literal, Self
 
-from prefect._internal.pydantic import HAS_PYDANTIC_V2
 from prefect._internal.schemas.validators import (
     cast_type_names_to_serializers,
     validate_compressionlib,
@@ -24,20 +25,29 @@ from prefect._internal.schemas.validators import (
     validate_picklelib,
     validate_picklelib_version,
 )
+from prefect.pydantic import HAS_PYDANTIC_V2
+from prefect.utilities.dispatch import get_dispatch_key, lookup_type, register_base_type
+from prefect.utilities.importtools import from_qualified_name, to_qualified_name
+from prefect.utilities.pydantic import custom_pydantic_encoder
 
 if HAS_PYDANTIC_V2:
-    import pydantic.v1 as pydantic
-    from pydantic.v1 import BaseModel
-    from pydantic.v1.json import pydantic_encoder
+    from pydantic.v1 import (
+        BaseModel,
+        Field,
+        ValidationError,
+        parse_obj_as,
+        root_validator,
+        validator,
+    )
 else:
-    import pydantic
-    from pydantic import BaseModel
-    from pydantic.json import pydantic_encoder
-
-from typing_extensions import Literal
-
-from prefect.utilities.importtools import from_qualified_name, to_qualified_name
-from prefect.utilities.pydantic import add_type_dispatch
+    from pydantic import (
+        BaseModel,
+        Field,
+        ValidationError,
+        parse_obj_as,
+        root_validator,
+        validator,
+    )
 
 D = TypeVar("D")
 
@@ -53,7 +63,7 @@ def prefect_json_object_encoder(obj: Any) -> Any:
     else:
         return {
             "__class__": to_qualified_name(obj.__class__),
-            "data": pydantic_encoder(obj),
+            "data": custom_pydantic_encoder({}, obj),
         }
 
 
@@ -63,21 +73,35 @@ def prefect_json_object_decoder(result: dict):
     with `prefect_json_object_encoder`
     """
     if "__class__" in result:
-        return pydantic.parse_obj_as(
-            from_qualified_name(result["__class__"]), result["data"]
-        )
+        return parse_obj_as(from_qualified_name(result["__class__"]), result["data"])
     elif "__exc_type__" in result:
         return from_qualified_name(result["__exc_type__"])(result["message"])
     else:
         return result
 
 
-@add_type_dispatch
+@register_base_type
 class Serializer(BaseModel, Generic[D], abc.ABC):
     """
     A serializer that can encode objects of type 'D' into bytes.
     """
 
+    def __init__(self, **data: Any) -> None:
+        type_string = get_dispatch_key(self) if type(self) != Serializer else "__base__"
+        data.setdefault("type", type_string)
+        super().__init__(**data)
+
+    def __new__(cls: Type[Self], **kwargs) -> Self:
+        if "type" in kwargs:
+            try:
+                subcls = lookup_type(cls, dispatch_key=kwargs["type"])
+            except KeyError as exc:
+                raise ValidationError(errors=[exc], model=cls)
+
+            return super().__new__(subcls)
+        else:
+            return super().__new__(cls)
+
     type: str
 
     @abc.abstractmethod
@@ -91,6 +115,10 @@ class Serializer(BaseModel, Generic[D], abc.ABC):
     class Config:
         extra = "forbid"
 
+    @classmethod
+    def __dispatch_key__(cls):
+        return cls.__fields__.get("type").get_default()
+
 
 class PickleSerializer(Serializer):
     """
@@ -107,11 +135,11 @@ class PickleSerializer(Serializer):
     picklelib: str = "cloudpickle"
     picklelib_version: str = None
 
-    @pydantic.validator("picklelib")
+    @validator("picklelib")
     def check_picklelib(cls, value):
         return validate_picklelib(value)
 
-    @pydantic.root_validator
+    @root_validator
     def check_picklelib_version(cls, values):
         return validate_picklelib_version(values)
 
@@ -135,16 +163,17 @@ class JSONSerializer(Serializer):
     """
 
     type: Literal["json"] = "json"
+
     jsonlib: str = "json"
-    object_encoder: Optional[str] = pydantic.Field(
+    object_encoder: Optional[str] = Field(
         default="prefect.serializers.prefect_json_object_encoder",
         description=(
             "An optional callable to use when serializing objects that are not "
             "supported by the JSON encoder. By default, this is set to a callable that "
-            "adds support for all types supported by Pydantic."
+            "adds support for all types supported by "
         ),
     )
-    object_decoder: Optional[str] = pydantic.Field(
+    object_decoder: Optional[str] = Field(
         default="prefect.serializers.prefect_json_object_decoder",
         description=(
             "An optional callable to use when deserializing objects. This callable "
@@ -153,14 +182,14 @@ class JSONSerializer(Serializer):
             "by our default `object_encoder`."
         ),
     )
-    dumps_kwargs: Dict[str, Any] = pydantic.Field(default_factory=dict)
-    loads_kwargs: Dict[str, Any] = pydantic.Field(default_factory=dict)
+    dumps_kwargs: Dict[str, Any] = Field(default_factory=dict)
+    loads_kwargs: Dict[str, Any] = Field(default_factory=dict)
 
-    @pydantic.validator("dumps_kwargs")
+    @validator("dumps_kwargs")
     def dumps_kwargs_cannot_contain_default(cls, value):
         return validate_dump_kwargs(value)
 
-    @pydantic.validator("loads_kwargs")
+    @validator("loads_kwargs")
     def loads_kwargs_cannot_contain_object_hook(cls, value):
         return validate_load_kwargs(value)
 
@@ -200,11 +229,11 @@ class CompressedSerializer(Serializer):
     serializer: Serializer
     compressionlib: str = "lzma"
 
-    @pydantic.validator("serializer", pre=True)
+    @validator("serializer", pre=True)
     def validate_serializer(cls, value):
         return cast_type_names_to_serializers(value)
 
-    @pydantic.validator("compressionlib")
+    @validator("compressionlib")
     def check_compressionlib(cls, value):
         return validate_compressionlib(value)
 
@@ -225,7 +254,8 @@ class CompressedPickleSerializer(CompressedSerializer):
     """
 
     type: Literal["compressed/pickle"] = "compressed/pickle"
-    serializer: Serializer = pydantic.Field(default_factory=PickleSerializer)
+
+    serializer: Serializer = Field(default_factory=PickleSerializer)
 
 
 class CompressedJSONSerializer(CompressedSerializer):
@@ -234,4 +264,5 @@ class CompressedJSONSerializer(CompressedSerializer):
     """
 
     type: Literal["compressed/json"] = "compressed/json"
-    serializer: Serializer = pydantic.Field(default_factory=JSONSerializer)
+
+    serializer: Serializer = Field(default_factory=JSONSerializer)

prefect/server/api/collections_data/views/aggregate-worker-metadata.json

@@ -111,10 +111,12 @@
               "taskRoleArn": "{{ task_role_arn }}"
             },
             "tags": "{{ labels }}",
-            "taskDefinition": "{{ task_definition_arn }}"
+            "taskDefinition": "{{ task_definition_arn }}",
+            "capacityProviderStrategy": "{{ capacity_provider_strategy }}"
           },
           "configure_cloudwatch_logs": "{{ configure_cloudwatch_logs }}",
           "cloudwatch_logs_options": "{{ cloudwatch_logs_options }}",
+          "cloudwatch_logs_prefix": "{{ cloudwatch_logs_prefix }}",
           "network_configuration": "{{ network_configuration }}",
           "stream_output": "{{ stream_output }}",
           "task_start_timeout_seconds": "{{ task_start_timeout_seconds }}",
@@ -191,6 +193,14 @@
               ],
               "type": "string"
             },
+            "capacity_provider_strategy": {
+              "title": "Capacity Provider Strategy",
+              "description": "The capacity provider strategy to use when running the task. If a capacity provider strategy is specified, the selected launch type will be ignored.",
+              "type": "array",
+              "items": {
+                "$ref": "#/definitions/CapacityProvider"
+              }
+            },
             "image": {
               "title": "Image",
               "description": "The image to use for the Prefect container in the task. If this value is not null, it will override the value in the task definition. This value defaults to a Prefect base image matching your local versions.",
@@ -239,6 +249,11 @@
                 "type": "string"
               }
             },
+            "cloudwatch_logs_prefix": {
+              "title": "Cloudwatch Logs Prefix",
+              "description": "When `configure_cloudwatch_logs` is enabled, this setting may be used to set a prefix for the log group. If not provided, the default prefix will be `prefect-logs_<work_pool_name>_<deployment_id>`. If `awslogs-stream-prefix` is present in `Cloudwatch logs options` this setting will be ignored.",
+              "type": "string"
+            },
             "network_configuration": {
               "title": "Network Configuration",
               "description": "When `network_configuration` is supplied it will override ECS Worker'sawsvpcConfiguration that defined in the ECS task executing your workload. See the [AWS documentation](https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-awsvpcconfiguration.html) for available options.",
@@ -370,6 +385,30 @@
                 "aws_secret_access_key"
               ],
               "block_schema_references": {}
+            },
+            "CapacityProvider": {
+              "title": "CapacityProvider",
+              "description": "The capacity provider strategy to use when running the task.",
+              "type": "object",
+              "properties": {
+                "capacityProvider": {
+                  "title": "Capacityprovider",
+                  "type": "string"
+                },
+                "weight": {
+                  "title": "Weight",
+                  "type": "integer"
+                },
+                "base": {
+                  "title": "Base",
+                  "type": "integer"
+                }
+              },
+              "required": [
+                "capacityProvider",
+                "weight",
+                "base"
+              ]
             }
           }
         }
@@ -1100,7 +1139,9 @@
                 "serviceAccount": "{{ service_account_name }}",
                 "maxRetries": "{{ max_retries }}",
                 "timeout": "{{ timeout }}",
-                "vpcAccess": "{{ vpc_connector_name }}",
+                "vpcAccess": {
+                  "connector": "{{ vpc_connector_name }}"
+                },
                 "containers": [
                   {
                     "env": [],
@@ -1647,4 +1688,4 @@
       "type": "kubernetes"
     }
   }
-}
+}

prefect/settings.py

@@ -109,6 +109,8 @@ REMOVED_EXPERIMENTAL_FLAGS = {
     "PREFECT_EXPERIMENTAL_ENABLE_ENHANCED_DEPLOYMENT_PARAMETERS",
     "PREFECT_EXPERIMENTAL_ENABLE_EVENTS_CLIENT",
     "PREFECT_EXPERIMENTAL_WARN_EVENTS_CLIENT",
+    "PREFECT_EXPERIMENTAL_ENABLE_FLOW_RUN_INFRA_OVERRIDES",
+    "PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES",
 }
 
 
@@ -1212,6 +1214,20 @@ PREFECT_API_SERVICES_CANCELLATION_CLEANUP_LOOP_SECONDS = Setting(
 this often. Defaults to `20`.
 """
 
+PREFECT_API_SERVICES_FOREMAN_ENABLED = Setting(bool, default=True)
+"""Whether or not to start the Foreman service in the server application."""
+
+PREFECT_API_SERVICES_FOREMAN_LOOP_SECONDS = Setting(float, default=15)
+"""The number of seconds to wait between each iteration of the Foreman loop which checks
+for offline workers and updates work pool status."""
+
+PREFECT_API_SERVICES_FOREMAN_DEPLOYMENT_LAST_POLLED_TIMEOUT_SECONDS = Setting(
+    int, default=60
+)
+"""The number of seconds before a deployment is marked as not ready if it has not been
+polled."""
+
+
 PREFECT_API_DEFAULT_LIMIT = Setting(
     int,
     default=200,
@@ -1542,16 +1558,6 @@ a task server should move a task from PENDING to RUNNING very quickly, so runs s
 PENDING for a while is a sign that the task server may have crashed.
 """
 
-PREFECT_EXPERIMENTAL_ENABLE_FLOW_RUN_INFRA_OVERRIDES = Setting(bool, default=False)
-"""
-Whether or not to enable infrastructure overrides made on flow runs.
-"""
-
-PREFECT_EXPERIMENTAL_WARN_FLOW_RUN_INFRA_OVERRIDES = Setting(bool, default=True)
-"""
-Whether or not to warn infrastructure when experimental flow runs overrides are used.
-"""
-
 PREFECT_EXPERIMENTAL_ENABLE_EXTRA_RUNNER_ENDPOINTS = Setting(bool, default=False)
 """
 Whether or not to enable experimental worker webserver endpoints.
@@ -1587,6 +1593,11 @@ PREFECT_EXPERIMENTAL_ENABLE_WORK_QUEUE_STATUS = Setting(bool, default=True)
 Whether or not to enable experimental work queue status in-place of work queue health.
 """
 
+PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE = Setting(bool, default=False)
+"""
+Whether or not to enable experimental new engine.
+"""
+
 
 # Defaults -----------------------------------------------------------------------------
 
@@ -1701,6 +1712,17 @@ PREFECT_API_SERVICES_EVENT_PERSISTER_FLUSH_INTERVAL = Setting(float, default=5,
 The maximum number of seconds between flushes of the event persister.
 """
 
+PREFECT_API_EVENTS_STREAM_OUT_ENABLED = Setting(bool, default=True)
+"""
+Whether or not to allow streaming events out of via websockets.
+"""
+
+PREFECT_API_EVENTS_RELATED_RESOURCE_CACHE_TTL = Setting(
+    timedelta, default=timedelta(minutes=5)
+)
+"""
+How long to cache related resource data for emitting server-side vents
+"""
 
 # Deprecated settings ------------------------------------------------------------------
 

prefect/states.py

@@ -486,8 +486,10 @@ class StateGroup:
 
 
 def Scheduled(
-    cls: Type[State] = State, scheduled_time: datetime.datetime = None, **kwargs
-) -> State:
+    cls: Type[State[R]] = State,
+    scheduled_time: Optional[datetime.datetime] = None,
+    **kwargs: Any,
+) -> State[R]:
     """Convenience function for creating `Scheduled` states.
 
     Returns:
@@ -503,7 +505,7 @@ def Scheduled(
     return cls(type=StateType.SCHEDULED, state_details=state_details, **kwargs)
 
 
-def Completed(cls: Type[State] = State, **kwargs) -> State:
+def Completed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Completed` states.
 
     Returns:
@@ -512,7 +514,7 @@ def Completed(cls: Type[State] = State, **kwargs) -> State:
     return cls(type=StateType.COMPLETED, **kwargs)
 
 
-def Running(cls: Type[State] = State, **kwargs) -> State:
+def Running(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Running` states.
 
     Returns:
@@ -521,7 +523,7 @@ def Running(cls: Type[State] = State, **kwargs) -> State:
     return cls(type=StateType.RUNNING, **kwargs)
 
 
-def Failed(cls: Type[State] = State, **kwargs) -> State:
+def Failed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Failed` states.
 
     Returns:
@@ -530,7 +532,7 @@ def Failed(cls: Type[State] = State, **kwargs) -> State:
     return cls(type=StateType.FAILED, **kwargs)
 
 
-def Crashed(cls: Type[State] = State, **kwargs) -> State:
+def Crashed(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Crashed` states.
 
     Returns:
@@ -539,7 +541,7 @@ def Crashed(cls: Type[State] = State, **kwargs) -> State:
     return cls(type=StateType.CRASHED, **kwargs)
 
 
-def Cancelling(cls: Type[State] = State, **kwargs) -> State:
+def Cancelling(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Cancelling` states.
 
     Returns:
@@ -548,7 +550,7 @@ def Cancelling(cls: Type[State] = State, **kwargs) -> State:
     return cls(type=StateType.CANCELLING, **kwargs)
 
 
-def Cancelled(cls: Type[State] = State, **kwargs) -> State:
+def Cancelled(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Cancelled` states.
 
     Returns:
@@ -557,7 +559,7 @@ def Cancelled(cls: Type[State] = State, **kwargs) -> State:
     return cls(type=StateType.CANCELLED, **kwargs)
 
 
-def Pending(cls: Type[State] = State, **kwargs) -> State:
+def Pending(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Pending` states.
 
     Returns:
@@ -567,13 +569,13 @@ def Pending(cls: Type[State] = State, **kwargs) -> State:
 
 
 def Paused(
-    cls: Type[State] = State,
+    cls: Type[State[R]] = State,
     timeout_seconds: Optional[int] = None,
     pause_expiration_time: Optional[datetime.datetime] = None,
     reschedule: bool = False,
     pause_key: Optional[str] = None,
-    **kwargs,
-) -> State:
+    **kwargs: Any,
+) -> State[R]:
     """Convenience function for creating `Paused` states.
 
     Returns:
@@ -603,11 +605,11 @@ def Paused(
 
 
 def Suspended(
-    cls: Type[State] = State,
+    cls: Type[State[R]] = State,
     timeout_seconds: Optional[int] = None,
     pause_expiration_time: Optional[datetime.datetime] = None,
     pause_key: Optional[str] = None,
-    **kwargs,
+    **kwargs: Any,
 ):
     """Convenience function for creating `Suspended` states.
 
@@ -626,8 +628,10 @@ def Suspended(
 
 
 def AwaitingRetry(
-    cls: Type[State] = State, scheduled_time: datetime.datetime = None, **kwargs
-) -> State:
+    cls: Type[State[R]] = State,
+    scheduled_time: Optional[datetime.datetime] = None,
+    **kwargs: Any,
+) -> State[R]:
     """Convenience function for creating `AwaitingRetry` states.
 
     Returns:
@@ -638,7 +642,7 @@ def AwaitingRetry(
     )
 
 
-def Retrying(cls: Type[State] = State, **kwargs) -> State:
+def Retrying(cls: Type[State[R]] = State, **kwargs: Any) -> State[R]:
     """Convenience function for creating `Retrying` states.
 
     Returns:
@@ -648,8 +652,10 @@ def Retrying(cls: Type[State] = State, **kwargs) -> State:
 
 
 def Late(
-    cls: Type[State] = State, scheduled_time: datetime.datetime = None, **kwargs
-) -> State:
+    cls: Type[State[R]] = State,
+    scheduled_time: Optional[datetime.datetime] = None,
+    **kwargs: Any,
+) -> State[R]:
     """Convenience function for creating `Late` states.
 
     Returns:

prefect/tasks.py

@@ -36,6 +36,7 @@ from prefect.context import FlowRunContext, PrefectObjectRegistry
 from prefect.futures import PrefectFuture
 from prefect.results import ResultSerializer, ResultStorage
 from prefect.settings import (
+    PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE,
     PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING,
     PREFECT_TASK_DEFAULT_RETRIES,
     PREFECT_TASK_DEFAULT_RETRY_DELAY_SECONDS,
@@ -582,6 +583,22 @@ class Task(Generic[P, R]):
                 self.isasync, self.name, parameters, self.viz_return_value
             )
 
+        # new engine currently only compatible with async tasks
+        if PREFECT_EXPERIMENTAL_ENABLE_NEW_ENGINE.value():
+            from prefect.new_task_engine import run_task
+            from prefect.utilities.asyncutils import run_sync
+
+            awaitable = run_task(
+                task=self,
+                parameters=parameters,
+                wait_for=wait_for,
+                return_type=return_type,
+            )
+            if self.isasync:
+                return awaitable
+            else:
+                return run_sync(awaitable)
+
         if (
             PREFECT_EXPERIMENTAL_ENABLE_TASK_SCHEDULING.value()
             and not FlowRunContext.get()