prefect-client 3.0.0rc15__py3-none-any.whl → 3.0.0rc17__py3-none-any.whl

prefect/flows.py

@@ -47,16 +47,12 @@ from pydantic.v1.errors import ConfigError  # TODO
 from rich.console import Console
 from typing_extensions import Literal, ParamSpec, Self
 
-from prefect._internal.compatibility.deprecated import (
-    deprecated_parameter,
-)
 from prefect._internal.concurrency.api import create_call, from_async
 from prefect.blocks.core import Block
 from prefect.client.orchestration import get_client
 from prefect.client.schemas.actions import DeploymentScheduleCreate
 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.docker.docker_image import DockerImage
 from prefect.events import DeploymentTriggerTypes, TriggerTypes
@@ -615,30 +611,23 @@ class Flow(Generic[P, R]):
             # do not serialize the bound self object
             if self.ismethod and value is self.fn.__prefect_self__:
                 continue
+            if isinstance(value, (PrefectFuture, State)):
+                # Don't call jsonable_encoder() on a PrefectFuture or State to
+                # avoid triggering a __getitem__ call
+                serialized_parameters[key] = f"<{type(value).__name__}>"
+                continue
             try:
                 serialized_parameters[key] = jsonable_encoder(value)
             except (TypeError, ValueError):
                 logger.debug(
-                    f"Parameter {key!r} for flow {self.name!r} is of unserializable "
-                    f"type {type(value).__name__!r} and will not be stored "
+                    f"Parameter {key!r} for flow {self.name!r} is unserializable. "
+                    f"Type {type(value).__name__!r} and will not be stored "
                     "in the backend."
                 )
                 serialized_parameters[key] = f"<{type(value).__name__}>"
         return serialized_parameters
 
     @sync_compatible
-    @deprecated_parameter(
-        "schedule",
-        start_date="Mar 2024",
-        when=lambda p: p is not None,
-        help="Use `schedules` instead.",
-    )
-    @deprecated_parameter(
-        "is_schedule_active",
-        start_date="Mar 2024",
-        when=lambda p: p is not None,
-        help="Use `paused` instead.",
-    )
     async def to_deployment(
         self,
         name: str,
@@ -654,8 +643,6 @@ class Flow(Generic[P, R]):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional[List["FlexibleScheduleList"]] = None,
-        schedule: Optional[SCHEDULE_TYPES] = None,
-        is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -679,10 +666,6 @@ class Flow(Generic[P, R]):
             paused: Whether or not to set this deployment as paused.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options such as `timezone`.
-            schedule: A schedule object defining when to execute runs of this deployment.
-            is_schedule_active: Whether or not to set the schedule for this deployment as active. If
-                not provided when creating a deployment, the schedule will be set as active. If not
-                provided when updating a deployment, the schedule's activation will not be changed.
             parameters: A dictionary of default parameter values to pass to runs of this deployment.
             triggers: A list of triggers that will kick off runs of this deployment.
             description: A description for the created deployment. Defaults to the flow's
@@ -735,8 +718,6 @@ class Flow(Generic[P, R]):
                 rrule=rrule,
                 paused=paused,
                 schedules=schedules,
-                schedule=schedule,
-                is_schedule_active=is_schedule_active,
                 tags=tags,
                 triggers=triggers,
                 parameters=parameters or {},
@@ -756,8 +737,6 @@ class Flow(Generic[P, R]):
                 rrule=rrule,
                 paused=paused,
                 schedules=schedules,
-                schedule=schedule,
-                is_schedule_active=is_schedule_active,
                 tags=tags,
                 triggers=triggers,
                 parameters=parameters or {},
@@ -815,8 +794,6 @@ class Flow(Generic[P, R]):
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        schedule: Optional[SCHEDULE_TYPES] = None,
-        is_schedule_active: Optional[bool] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
@@ -846,11 +823,6 @@ class Flow(Generic[P, R]):
             paused: Whether or not to set this deployment as paused.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
-            schedule: A schedule object defining when to execute runs of this deployment. Used to
-                define additional scheduling options such as `timezone`.
-            is_schedule_active: Whether or not to set the schedule for this deployment as active. If
-                not provided when creating a deployment, the schedule will be set as active. If not
-                provided when updating a deployment, the schedule's activation will not be changed.
             parameters: A dictionary of default parameter values to pass to runs of this deployment.
             description: A description for the created deployment. Defaults to the flow's
                 description if not provided.
@@ -914,8 +886,6 @@ class Flow(Generic[P, R]):
             rrule=rrule,
             paused=paused,
             schedules=schedules,
-            schedule=schedule,
-            is_schedule_active=is_schedule_active,
             parameters=parameters,
             description=description,
             tags=tags,
@@ -1085,8 +1055,6 @@ class Flow(Generic[P, R]):
         rrule: Optional[str] = None,
         paused: Optional[bool] = None,
         schedules: Optional[List[DeploymentScheduleCreate]] = None,
-        schedule: Optional[SCHEDULE_TYPES] = None,
-        is_schedule_active: Optional[bool] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         parameters: Optional[dict] = None,
         description: Optional[str] = None,
@@ -1133,11 +1101,6 @@ class Flow(Generic[P, R]):
             paused: Whether or not to set this deployment as paused.
             schedules: A list of schedule objects defining when to execute runs of this deployment.
                 Used to define multiple schedules or additional scheduling options like `timezone`.
-            schedule: A schedule object defining when to execute runs of this deployment. Used to
-                define additional scheduling options like `timezone`.
-            is_schedule_active: Whether or not to set the schedule for this deployment as active. If
-                not provided when creating a deployment, the schedule will be set as active. If not
-                provided when updating a deployment, the schedule's activation will not be changed.
             parameters: A dictionary of default parameter values to pass to runs of this deployment.
             description: A description for the created deployment. Defaults to the flow's
                 description if not provided.
@@ -1213,8 +1176,6 @@ class Flow(Generic[P, R]):
             rrule=rrule,
             schedules=schedules,
             paused=paused,
-            schedule=schedule,
-            is_schedule_active=is_schedule_active,
             triggers=triggers,
             parameters=parameters,
             description=description,

prefect/runner/runner.py

@@ -67,7 +67,6 @@ from prefect.client.schemas.filters import (
 )
 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.events import DeploymentTriggerTypes, TriggerTypes
 from prefect.events.related import tags_as_related_resources
 from prefect.events.schemas.events import RelatedResource
@@ -224,8 +223,6 @@ class Runner:
         rrule: Optional[Union[Iterable[str], str]] = None,
         paused: Optional[bool] = None,
         schedules: Optional["FlexibleScheduleList"] = None,
-        schedule: Optional[SCHEDULE_TYPES] = None,
-        is_schedule_active: Optional[bool] = None,
         parameters: Optional[dict] = None,
         triggers: Optional[List[Union[DeploymentTriggerTypes, TriggerTypes]]] = None,
         description: Optional[str] = None,
@@ -248,11 +245,6 @@ class Runner:
                 or a timedelta object. If a number is given, it will be interpreted as seconds.
             cron: A cron schedule of when to execute runs of this flow.
             rrule: An rrule schedule of when to execute runs of this flow.
-            schedule: A schedule object of when to execute runs of this flow. Used for
-                advanced scheduling options like timezone.
-            is_schedule_active: Whether or not to set the schedule for this deployment as active. If
-                not provided when creating a deployment, the schedule will be set as active. If not
-                provided when updating a deployment, the schedule's activation will not be changed.
             triggers: A list of triggers that should kick of a run of this flow.
             parameters: A dictionary of default parameter values to pass to runs of this flow.
             description: A description for the created deployment. Defaults to the flow's
@@ -277,9 +269,7 @@ class Runner:
             cron=cron,
             rrule=rrule,
             schedules=schedules,
-            schedule=schedule,
             paused=paused,
-            is_schedule_active=is_schedule_active,
             triggers=triggers,
             parameters=parameters,
             description=description,

prefect/runtime/flow_run.py

@@ -12,6 +12,7 @@ Available attributes:
     - `scheduled_start_time`: the flow run's expected scheduled start time; defaults to now if not present
     - `name`: the name of the flow run
     - `flow_name`: the name of the flow
+    - `flow_version`: the version of the flow
     - `parameters`: the parameters that were passed to this run; note that these do not necessarily
         include default values set on the flow function, only the parameter values explicitly passed for the run
     - `parent_flow_run_id`: the ID of the flow run that triggered this run, if any
@@ -35,6 +36,7 @@ __all__ = [
     "scheduled_start_time",
     "name",
     "flow_name",
+    "flow_version",
     "parameters",
     "parent_flow_run_id",
     "parent_deployment_id",
@@ -119,7 +121,7 @@ async def _get_flow_from_run(flow_run_id):
         return await client.read_flow(flow_run.flow_id)
 
 
-def get_id() -> str:
+def get_id() -> Optional[str]:
     flow_run_ctx = FlowRunContext.get()
     task_run_ctx = TaskRunContext.get()
     if flow_run_ctx is not None:
@@ -190,6 +192,21 @@ def get_flow_name() -> Optional[str]:
         return flow_run_ctx.flow.name
 
 
+def get_flow_version() -> Optional[str]:
+    flow_run_ctx = FlowRunContext.get()
+    run_id = get_id()
+    if flow_run_ctx is None and run_id is None:
+        return None
+    elif flow_run_ctx is None:
+        flow = from_sync.call_soon_in_loop_thread(
+            create_call(_get_flow_from_run, run_id)
+        ).result()
+
+        return flow.version
+    else:
+        return flow_run_ctx.flow.version
+
+
 def get_scheduled_start_time() -> pendulum.DateTime:
     flow_run_ctx = FlowRunContext.get()
     run_id = get_id()
@@ -313,4 +330,5 @@ FIELDS = {
     "run_count": get_run_count,
     "api_url": get_flow_run_api_url,
     "ui_url": get_flow_run_ui_url,
+    "flow_version": get_flow_version,
 }

prefect/settings.py

@@ -323,7 +323,11 @@ def template_with_settings(*upstream_settings: Setting) -> Callable[["Settings",
             setting.name: setting.value_from(settings) for setting in upstream_settings
         }
         template = string.Template(str(value))
-        return original_type(template.substitute(template_values))
+        # Note the use of `safe_substitute` to avoid raising an exception if a
+        # template value is missing. In this case, template values will be left
+        # as-is in the string. Using `safe_substitute` prevents us raising when
+        # the DB password contains a `$` character.
+        return original_type(template.safe_substitute(template_values))
 
     return templater
 

prefect/task_engine.py

@@ -5,7 +5,6 @@ import time
 from asyncio import CancelledError
 from contextlib import ExitStack, asynccontextmanager, contextmanager
 from dataclasses import dataclass, field
-from functools import wraps
 from textwrap import dedent
 from typing import (
     Any,
@@ -212,6 +211,9 @@ class BaseTaskRunEngine(Generic[P, R]):
         return task_run.state.is_running() or task_run.state.is_scheduled()
 
     def log_finished_message(self):
+        if not self.task_run:
+            return
+
         # If debugging, use the more complete `repr` than the usual `str` description
         display_state = repr(self.state) if PREFECT_DEBUG_MODE else str(self.state)
         level = logging.INFO if self.state.is_completed() else logging.ERROR
@@ -231,11 +233,11 @@ class BaseTaskRunEngine(Generic[P, R]):
 
                         @task
                         def say_hello(name):
-                            print f"Hello, {name}!"
+                            print(f"Hello, {name}!")
 
                         @flow
                         def example_flow():
-                            future = say_hello.submit(name="Marvin)
+                            future = say_hello.submit(name="Marvin")
                             future.wait()
 
                         example_flow()
@@ -364,7 +366,7 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.task_run.run_count += 1
 
             flow_run_context = FlowRunContext.get()
-            if flow_run_context:
+            if flow_run_context and flow_run_context.flow_run:
                 # Carry forward any task run information from the flow run
                 flow_run = flow_run_context.flow_run
                 self.task_run.flow_run_run_count = flow_run.run_count
@@ -496,15 +498,8 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         )
         transaction.stage(
             terminal_state.data,
-            on_rollback_hooks=[self.handle_rollback]
-            + [
-                _with_transaction_hook_logging(hook, "rollback", self.logger)
-                for hook in self.task.on_rollback_hooks
-            ],
-            on_commit_hooks=[
-                _with_transaction_hook_logging(hook, "commit", self.logger)
-                for hook in self.task.on_commit_hooks
-            ],
+            on_rollback_hooks=[self.handle_rollback] + self.task.on_rollback_hooks,
+            on_commit_hooks=self.task.on_commit_hooks,
         )
         if transaction.is_committed():
             terminal_state.name = "Cached"
@@ -630,21 +625,24 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
             self.logger = task_run_logger(task_run=self.task_run, task=self.task)  # type: ignore
 
-            if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
-                # update the task run name if necessary
-                if not self._task_name_set and self.task.task_run_name:
-                    task_run_name = _resolve_custom_task_run_name(
-                        task=self.task, parameters=self.parameters
-                    )
+            # update the task run name if necessary
+            if not self._task_name_set and self.task.task_run_name:
+                task_run_name = _resolve_custom_task_run_name(
+                    task=self.task, parameters=self.parameters
+                )
+
+                if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+                    # update the task run name if necessary
                     self.client.set_task_run_name(
                         task_run_id=self.task_run.id, name=task_run_name
                     )
-                    self.logger.extra["task_run_name"] = task_run_name
-                    self.logger.debug(
-                        f"Renamed task run {self.task_run.name!r} to {task_run_name!r}"
-                    )
-                    self.task_run.name = task_run_name
-                    self._task_name_set = True
+
+                self.logger.extra["task_run_name"] = task_run_name
+                self.logger.debug(
+                    f"Renamed task run {self.task_run.name!r} to {task_run_name!r}"
+                )
+                self.task_run.name = task_run_name
+                self._task_name_set = True
             yield
 
     @contextmanager
@@ -663,21 +661,6 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                 self._is_started = True
                 try:
                     if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
-                        from prefect.utilities.engine import (
-                            _resolve_custom_task_run_name,
-                        )
-
-                        task_run_name = (
-                            _resolve_custom_task_run_name(
-                                task=self.task, parameters=self.parameters
-                            )
-                            if self.task.task_run_name
-                            else None
-                        )
-
-                        if self.task_run and task_run_name:
-                            self.task_run.name = task_run_name
-
                         if not self.task_run:
                             self.task_run = run_coro_as_sync(
                                 self.task.create_local_run(
@@ -687,7 +670,6 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                                     parent_task_run_context=TaskRunContext.get(),
                                     wait_for=self.wait_for,
                                     extra_task_inputs=dependencies,
-                                    task_run_name=task_run_name,
                                 )
                             )
                             # Emit an event to capture that the task run was in the `PENDING` state.
@@ -1068,15 +1050,8 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
         )
         transaction.stage(
             terminal_state.data,
-            on_rollback_hooks=[self.handle_rollback]
-            + [
-                _with_transaction_hook_logging(hook, "rollback", self.logger)
-                for hook in self.task.on_rollback_hooks
-            ],
-            on_commit_hooks=[
-                _with_transaction_hook_logging(hook, "commit", self.logger)
-                for hook in self.task.on_commit_hooks
-            ],
+            on_rollback_hooks=[self.handle_rollback] + self.task.on_rollback_hooks,
+            on_commit_hooks=self.task.on_commit_hooks,
         )
         if transaction.is_committed():
             terminal_state.name = "Cached"
@@ -1200,21 +1175,21 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
 
             self.logger = task_run_logger(task_run=self.task_run, task=self.task)  # type: ignore
 
-            if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
-                # update the task run name if necessary
-                if not self._task_name_set and self.task.task_run_name:
-                    task_run_name = _resolve_custom_task_run_name(
-                        task=self.task, parameters=self.parameters
-                    )
+            if not self._task_name_set and self.task.task_run_name:
+                task_run_name = _resolve_custom_task_run_name(
+                    task=self.task, parameters=self.parameters
+                )
+                if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
+                    # update the task run name if necessary
                     await self.client.set_task_run_name(
                         task_run_id=self.task_run.id, name=task_run_name
                     )
-                    self.logger.extra["task_run_name"] = task_run_name
-                    self.logger.debug(
-                        f"Renamed task run {self.task_run.name!r} to {task_run_name!r}"
-                    )
-                    self.task_run.name = task_run_name
-                    self._task_name_set = True
+                self.logger.extra["task_run_name"] = task_run_name
+                self.logger.debug(
+                    f"Renamed task run {self.task_run.name!r} to {task_run_name!r}"
+                )
+                self.task_run.name = task_run_name
+                self._task_name_set = True
             yield
 
     @asynccontextmanager
@@ -1233,21 +1208,6 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                 self._is_started = True
                 try:
                     if PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
-                        from prefect.utilities.engine import (
-                            _resolve_custom_task_run_name,
-                        )
-
-                        task_run_name = (
-                            _resolve_custom_task_run_name(
-                                task=self.task, parameters=self.parameters
-                            )
-                            if self.task.task_run_name
-                            else None
-                        )
-
-                        if self.task_run and task_run_name:
-                            self.task_run.name = task_run_name
-
                         if not self.task_run:
                             self.task_run = await self.task.create_local_run(
                                 id=task_run_id,
@@ -1256,7 +1216,6 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
                                 parent_task_run_context=TaskRunContext.get(),
                                 wait_for=self.wait_for,
                                 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(
@@ -1622,28 +1581,3 @@ def run_task(
         return run_task_async(**kwargs)
     else:
         return run_task_sync(**kwargs)
-
-
-def _with_transaction_hook_logging(
-    hook: Callable[[Transaction], None],
-    hook_type: Literal["rollback", "commit"],
-    logger: logging.Logger,
-) -> Callable[[Transaction], None]:
-    @wraps(hook)
-    def _hook(txn: Transaction) -> None:
-        hook_name = _get_hook_name(hook)
-        logger.info(f"Running {hook_type} hook {hook_name!r}")
-
-        try:
-            hook(txn)
-        except Exception as exc:
-            logger.error(
-                f"An error was encountered while running {hook_type} hook {hook_name!r}",
-            )
-            raise exc
-        else:
-            logger.info(
-                f"{hook_type.capitalize()} hook {hook_name!r} finished running successfully"
-            )
-
-    return _hook

prefect/tasks.py

@@ -814,7 +814,6 @@ class Task(Generic[P, R]):
         wait_for: Optional[Iterable[PrefectFuture]] = None,
         extra_task_inputs: Optional[Dict[str, Set[TaskRunInput]]] = None,
         deferred: bool = False,
-        task_run_name: Optional[str] = None,
     ) -> TaskRun:
         if not PREFECT_EXPERIMENTAL_ENABLE_CLIENT_SIDE_TASK_ORCHESTRATION:
             raise RuntimeError(
@@ -839,12 +838,12 @@ class Task(Generic[P, R]):
         async with client:
             if not flow_run_context:
                 dynamic_key = f"{self.task_key}-{str(uuid4().hex)}"
-                task_run_name = task_run_name or self.name
+                task_run_name = self.name
             else:
                 dynamic_key = _dynamic_key_for_task_run(
                     context=flow_run_context, task=self
                 )
-                task_run_name = task_run_name or f"{self.name}-{dynamic_key}"
+                task_run_name = f"{self.name}-{dynamic_key}"
 
             if deferred:
                 state = Scheduled()

prefect/transactions.py

@@ -1,9 +1,11 @@
+import copy
 import logging
 from contextlib import contextmanager
 from contextvars import ContextVar, Token
 from typing import (
     Any,
     Callable,
+    Dict,
     Generator,
     List,
     Optional,
@@ -11,7 +13,7 @@ from typing import (
     Union,
 )
 
-from pydantic import Field
+from pydantic import Field, PrivateAttr
 from typing_extensions import Self
 
 from prefect.context import ContextModel, FlowRunContext, TaskRunContext
@@ -24,8 +26,10 @@ from prefect.results import (
     ResultFactory,
     get_default_result_storage,
 )
+from prefect.utilities.annotations import NotSet
 from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.collections import AutoEnum
+from prefect.utilities.engine import _get_hook_name
 
 
 class IsolationLevel(AutoEnum):
@@ -63,9 +67,20 @@ class Transaction(ContextModel):
     )
     overwrite: bool = False
     logger: Union[logging.Logger, logging.LoggerAdapter, None] = None
+    _stored_values: Dict[str, Any] = PrivateAttr(default_factory=dict)
     _staged_value: Any = None
     __var__: ContextVar = ContextVar("transaction")
 
+    def set(self, name: str, value: Any) -> None:
+        self._stored_values[name] = value
+
+    def get(self, name: str, default: Any = NotSet) -> Any:
+        if name not in self._stored_values:
+            if default is not NotSet:
+                return default
+            raise ValueError(f"Could not retrieve value for unknown key: {name}")
+        return self._stored_values.get(name)
+
     def is_committed(self) -> bool:
         return self.state == TransactionState.COMMITTED
 
@@ -93,6 +108,7 @@ class Transaction(ContextModel):
             # either inherit from parent or set a default of eager
             if parent:
                 self.commit_mode = parent.commit_mode
+                self._stored_values = copy.deepcopy(parent._stored_values)
             else:
                 self.commit_mode = CommitMode.LAZY
 
@@ -183,7 +199,7 @@ class Transaction(ContextModel):
                 child.commit()
 
             for hook in self.on_commit_hooks:
-                hook(self)
+                self.run_hook(hook, "commit")
 
             if self.store and self.key:
                 self.store.write(key=self.key, value=self._staged_value)
@@ -198,6 +214,22 @@ class Transaction(ContextModel):
             self.rollback()
             return False
 
+    def run_hook(self, hook, hook_type: str) -> None:
+        hook_name = _get_hook_name(hook)
+        self.logger.info(f"Running {hook_type} hook {hook_name!r}")
+
+        try:
+            hook(self)
+        except Exception as exc:
+            self.logger.error(
+                f"An error was encountered while running {hook_type} hook {hook_name!r}",
+            )
+            raise exc
+        else:
+            self.logger.info(
+                f"{hook_type.capitalize()} hook {hook_name!r} finished running successfully"
+            )
+
     def stage(
         self,
         value: BaseResult,
@@ -222,7 +254,7 @@ class Transaction(ContextModel):
 
         try:
             for hook in reversed(self.on_rollback_hooks):
-                hook(self)
+                self.run_hook(hook, "rollback")
 
             self.state = TransactionState.ROLLED_BACK
 

prefect/workers/base.py

@@ -930,7 +930,12 @@ class BaseWorker(abc.ABC):
 
         deployment_vars = deployment.job_variables or {}
         flow_run_vars = flow_run.job_variables or {}
-        job_variables = {**deployment_vars, **flow_run_vars}
+        job_variables = {**deployment_vars}
+
+        # merge environment variables carefully, otherwise full override
+        if isinstance(job_variables.get("env"), dict):
+            job_variables["env"].update(flow_run_vars.pop("env", {}))
+        job_variables.update(flow_run_vars)
 
         configuration = await self.job_configuration.from_template_and_values(
             base_job_template=self._work_pool.base_job_template,

{prefect_client-3.0.0rc15.dist-info → prefect_client-3.0.0rc17.dist-info}/METADATA

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