prefect-client 3.4.16.dev4__tar.gz → 3.4.16.dev6__tar.gz

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: prefect-client
-Version: 3.4.16.dev4
+Version: 3.4.16.dev6
 Summary: Workflow orchestration and management.
 Project-URL: Changelog, https://github.com/PrefectHQ/prefect/releases
 Project-URL: Documentation, https://docs.prefect.io

prefect_client-3.4.16.dev6/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.4.16.dev6"
+__build_date__ = "2025-09-05 08:08:35.939479+00:00"
+__git_commit__ = "049536d3a8b4706effb6a15ba0f9e8677c7efc4d"
+__dirty__ = False

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/_internal/schemas/validators.py

@@ -134,12 +134,12 @@ def convert_to_strings(value: Union[Any, Iterable[Any]]) -> Union[str, list[str]
 
 def reconcile_schedules_runner(values: MM) -> MM:
     from prefect.deployments.schedules import (
-        normalize_to_deployment_schedule_create,
+        normalize_to_deployment_schedule,
     )
 
     schedules = values.get("schedules")
     if schedules is not None and len(schedules) > 0:
-        values["schedules"] = normalize_to_deployment_schedule_create(schedules)
+        values["schedules"] = normalize_to_deployment_schedule(schedules)
 
     return values
 

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/client/schemas/actions.py

@@ -173,8 +173,8 @@ class DeploymentScheduleUpdate(ActionBaseModel):
     schedule: Optional[SCHEDULE_TYPES] = Field(
         default=None, description="The schedule for the deployment."
     )
-    active: bool = Field(
-        default=True, description="Whether or not the schedule is active."
+    active: Optional[bool] = Field(
+        default=None, description="Whether or not the schedule is active."
     )
 
     max_scheduled_runs: Optional[PositiveInteger] = Field(
@@ -316,7 +316,7 @@ class DeploymentUpdate(ActionBaseModel):
     paused: Optional[bool] = Field(
         default=None, description="Whether or not the deployment is paused."
     )
-    schedules: Optional[list[DeploymentScheduleCreate]] = Field(
+    schedules: Optional[list[DeploymentScheduleUpdate]] = Field(
         default=None,
         description="A list of schedules for the deployment.",
     )

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/context.py

@@ -457,7 +457,7 @@ class TaskRunContext(RunContext):
     __var__: ClassVar[ContextVar[Self]] = ContextVar("task_run")
 
     def serialize(self: Self, include_secrets: bool = True) -> dict[str, Any]:
-        return self.model_dump(
+        serialized = self.model_dump(
             include={
                 "task_run",
                 "task",
@@ -465,13 +465,18 @@ class TaskRunContext(RunContext):
                 "log_prints",
                 "start_time",
                 "input_keyset",
-                "result_store",
                 "persist_result",
             },
             exclude_unset=True,
-            serialize_as_any=True,
             context={"include_secrets": include_secrets},
         )
+        if self.result_store:
+            serialized["result_store"] = self.result_store.model_dump(
+                serialize_as_any=True,
+                exclude_unset=True,
+                context={"include_secrets": include_secrets},
+            )
+        return serialized
 
 
 class AssetContext(ContextModel):

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/deployments/base.py

@@ -229,14 +229,15 @@ def _format_deployment_for_saving_to_prefect_file(
     if deployment.get("schedules"):
         schedules: list[dict[str, Any]] = []
         for deployment_schedule in deployment["schedules"]:
-            if isinstance(deployment_schedule.schedule, IntervalSchedule):
+            if isinstance(deployment_schedule["schedule"], IntervalSchedule):
                 schedule_config = _interval_schedule_to_dict(
-                    deployment_schedule.schedule
+                    deployment_schedule["schedule"]
                 )
             else:  # all valid SCHEDULE_TYPES are subclasses of BaseModel
-                schedule_config = deployment_schedule.schedule.model_dump()
+                schedule_config = deployment_schedule["schedule"].model_dump()
 
-            schedule_config["active"] = deployment_schedule.active
+            if "active" in deployment_schedule:
+                schedule_config["active"] = deployment_schedule["active"]
             schedules.append(schedule_config)
 
         deployment["schedules"] = schedules

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/deployments/runner.py

@@ -69,7 +69,11 @@ from prefect._internal.schemas.validators import (
 from prefect._versioning import VersionType, get_inferred_version_info
 from prefect.client.base import ServerType
 from prefect.client.orchestration import PrefectClient, get_client
-from prefect.client.schemas.actions import DeploymentScheduleCreate, DeploymentUpdate
+from prefect.client.schemas.actions import (
+    DeploymentScheduleCreate,
+    DeploymentScheduleUpdate,
+    DeploymentUpdate,
+)
 from prefect.client.schemas.filters import WorkerFilter, WorkerFilterStatus
 from prefect.client.schemas.objects import (
     ConcurrencyLimitConfig,
@@ -174,7 +178,9 @@ class RunnerDeployment(BaseModel):
         default_factory=list,
         description="One of more tags to apply to this deployment.",
     )
-    schedules: Optional[List[DeploymentScheduleCreate]] = Field(
+    schedules: Optional[
+        List[Union[DeploymentScheduleCreate, DeploymentScheduleUpdate]]
+    ] = Field(
         default=None,
         description="The schedules that should cause this deployment to run.",
     )
@@ -434,6 +440,12 @@ class RunnerDeployment(BaseModel):
         else:
             update_payload["pull_steps"] = None
 
+        if self.schedules:
+            update_payload["schedules"] = [
+                schedule.model_dump(mode="json", exclude_unset=True)
+                for schedule in self.schedules
+            ]
+
         await client.update_deployment(
             deployment_id,
             deployment=DeploymentUpdate(
@@ -480,6 +492,7 @@ class RunnerDeployment(BaseModel):
     @sync_compatible
     async def apply(
         self,
+        schedules: Optional[List[dict[str, Any]]] = None,
         work_pool_name: Optional[str] = None,
         image: Optional[str] = None,
         version_info: Optional[VersionInfo] = None,
@@ -506,12 +519,20 @@ class RunnerDeployment(BaseModel):
             try:
                 deployment = await client.read_deployment_by_name(self.full_name)
             except ObjectNotFound:
+                if schedules:
+                    self.schedules = [
+                        DeploymentScheduleCreate(**schedule) for schedule in schedules
+                    ]
                 return await self._create(work_pool_name, image, version_info)
             else:
                 if image:
                     self.job_variables["image"] = image
                 if work_pool_name:
                     self.work_pool_name = work_pool_name
+                if schedules:
+                    self.schedules = [
+                        DeploymentScheduleUpdate(**schedule) for schedule in schedules
+                    ]
                 return await self._update(deployment.id, client, version_info)
 
     async def _create_slas(self, deployment_id: UUID, client: PrefectClient):

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/deployments/schedules.py

@@ -1,6 +1,9 @@
 from typing import TYPE_CHECKING, Any, List, Optional, Sequence, Union
 
-from prefect.client.schemas.actions import DeploymentScheduleCreate
+from prefect.client.schemas.actions import (
+    DeploymentScheduleCreate,
+    DeploymentScheduleUpdate,
+)
 from prefect.client.schemas.schedules import is_schedule_type
 from prefect.schedules import Schedule
 
@@ -26,10 +29,10 @@ def create_deployment_schedule_create(
     )
 
 
-def normalize_to_deployment_schedule_create(
+def normalize_to_deployment_schedule(
     schedules: Optional["FlexibleScheduleList"],
-) -> List[DeploymentScheduleCreate]:
-    normalized: list[DeploymentScheduleCreate] = []
+) -> List[Union[DeploymentScheduleCreate, DeploymentScheduleUpdate]]:
+    normalized: list[Union[DeploymentScheduleCreate, DeploymentScheduleUpdate]] = []
     if schedules is not None:
         for obj in schedules:
             if is_schedule_type(obj):
@@ -40,6 +43,8 @@ def normalize_to_deployment_schedule_create(
                 normalized.append(create_deployment_schedule_create(**obj))
             elif isinstance(obj, DeploymentScheduleCreate):
                 normalized.append(obj)
+            elif isinstance(obj, DeploymentScheduleUpdate):
+                normalized.append(obj)
             elif _is_server_schema(obj):
                 raise ValueError(
                     "Server schema schedules are not supported. Please use "

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/filesystems.py

@@ -515,6 +515,10 @@ class RemoteFileSystem(WritableFileSystem, WritableDeploymentStorage):
         path = self._resolve_path(path)
         dirpath = path[: path.rindex("/")]
 
+        if self.basepath.startswith("smb://"):
+            parsed = urllib.parse.urlparse(dirpath)
+            dirpath = parsed.path
+
         self.filesystem.makedirs(dirpath, exist_ok=True)
 
         with self.filesystem.open(path, "wb") as file:

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/futures.py

@@ -271,23 +271,17 @@ class PrefectDistributedFuture(PrefectTaskRunFuture[R]):
                 "Waiting for completed event for task run %s...",
                 self.task_run_id,
             )
-            await TaskRunWaiter.wait_for_task_run(self._task_run_id, timeout=timeout)
+            state_from_event = await TaskRunWaiter.wait_for_task_run(
+                self._task_run_id, timeout=timeout
+            )
 
-            # After the waiter returns, we expect the task to be complete.
-            # However, there may be a small delay before the API reflects the final state
-            # due to eventual consistency between the event system and the API.
-            # We'll read the state and only cache it if it's final.
-            task_run = await client.read_task_run(task_run_id=self._task_run_id)
-            if task_run.state and task_run.state.is_final():
-                self._final_state = task_run.state
-            else:
-                # Don't cache non-final states to avoid persisting stale data.
-                # result_async() will handle reading the state again if needed.
+            if state_from_event:
+                # We got the final state directly from the event
+                self._final_state = state_from_event
                 logger.debug(
-                    "Task run %s state not yet final after wait (state: %s). "
-                    "State will be re-read when needed.",
+                    "Task run %s completed with state from event: %s",
                     self.task_run_id,
-                    task_run.state.type if task_run.state else "Unknown",
+                    state_from_event.type,
                 )
             return
 
@@ -308,8 +302,8 @@ class PrefectDistributedFuture(PrefectTaskRunFuture[R]):
         if not self._final_state:
             await self.wait_async(timeout=timeout)
             if not self._final_state:
-                # If still no final state, try reading it directly as the
-                # state property does. This handles eventual consistency issues.
+                # If still no final state after wait, try reading it once more.
+                # This should rarely happen since wait_async() now gets state from events.
                 async with get_client() as client:
                     task_run = await client.read_task_run(task_run_id=self._task_run_id)
                     if task_run.state and task_run.state.is_final():

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/runner/storage.py

@@ -384,9 +384,14 @@ class GitRepository:
             await run_process(cmd)
         except subprocess.CalledProcessError as exc:
             # Hide the command used to avoid leaking the access token
-            exc_chain = None if self._credentials else exc
+            parsed_url = urlparse(self._url)
+            exc_chain = (
+                None
+                if self._credentials or parsed_url.password or parsed_url.username
+                else exc
+            )
             raise RuntimeError(
-                f"Failed to clone repository {self._url!r} with exit code"
+                f"Failed to clone repository {_strip_auth_from_url(self._url)!r} with exit code"
                 f" {exc.returncode}."
             ) from exc_chain
 

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/task_engine.py

@@ -574,15 +574,16 @@ class SyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.retries: int = self.retries + 1
             return True
         elif self.retries >= self.task.retries:
-            retry_message_suffix = (
-                "Retries are exhausted"
-                if self.task.retries > 0
-                else "No retries configured for this task."
-            )
-            self.logger.error(
-                f"Task run failed with {failure_type}: {exc_or_state!r} - {retry_message_suffix}",
-                exc_info=True,
-            )
+            if self.task.retries > 0:
+                self.logger.error(
+                    f"Task run failed with {failure_type}: {exc_or_state!r} - Retries are exhausted",
+                    exc_info=True,
+                )
+            else:
+                self.logger.error(
+                    f"Task run failed with {failure_type}: {exc_or_state!r}",
+                    exc_info=True,
+                )
             return False
 
         return False
@@ -1164,15 +1165,16 @@ class AsyncTaskRunEngine(BaseTaskRunEngine[P, R]):
             self.retries: int = self.retries + 1
             return True
         elif self.retries >= self.task.retries:
-            retry_message_suffix = (
-                "Retries are exhausted"
-                if self.task.retries > 0
-                else "No retries configured for this task."
-            )
-            self.logger.error(
-                f"Task run failed with {failure_type}: {exc_or_state!r} - {retry_message_suffix}",
-                exc_info=True,
-            )
+            if self.task.retries > 0:
+                self.logger.error(
+                    f"Task run failed with {failure_type}: {exc_or_state!r} - Retries are exhausted",
+                    exc_info=True,
+                )
+            else:
+                self.logger.error(
+                    f"Task run failed with {failure_type}: {exc_or_state!r}",
+                    exc_info=True,
+                )
             return False
 
         return False

{prefect_client-3.4.16.dev4 → prefect_client-3.4.16.dev6}/src/prefect/task_runs.py

@@ -4,7 +4,7 @@ import asyncio
 import atexit
 import threading
 import uuid
-from typing import TYPE_CHECKING, Callable, Dict, Optional
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional
 
 import anyio
 from cachetools import TTLCache
@@ -16,6 +16,7 @@ from prefect.client.schemas.objects import TERMINAL_STATES
 from prefect.events.clients import get_events_subscriber
 from prefect.events.filters import EventFilter, EventNameFilter
 from prefect.logging.loggers import get_logger
+from prefect.states import State
 
 if TYPE_CHECKING:
     import logging
@@ -75,9 +76,9 @@ class TaskRunWaiter:
     def __init__(self):
         self.logger: "logging.Logger" = get_logger("TaskRunWaiter")
         self._consumer_task: "asyncio.Task[None] | None" = None
-        self._observed_completed_task_runs: TTLCache[uuid.UUID, bool] = TTLCache(
-            maxsize=10000, ttl=600
-        )
+        self._observed_completed_task_runs: TTLCache[
+            uuid.UUID, Optional[State[Any]]
+        ] = TTLCache(maxsize=10000, ttl=600)
         self._completion_events: Dict[uuid.UUID, asyncio.Event] = {}
         self._completion_callbacks: Dict[uuid.UUID, Callable[[], None]] = {}
         self._loop: Optional[asyncio.AbstractEventLoop] = None
@@ -134,10 +135,22 @@ class TaskRunWaiter:
                         )
                     )
 
+                    # Extract the state from the event
+                    # All events should have validated_state since we don't support
+                    # new clients with old servers
+                    state_data = State.model_validate(
+                        {
+                            "id": event.id,
+                            "timestamp": event.occurred,
+                            **event.payload["validated_state"],
+                        }
+                    )
+                    state_data.state_details.task_run_id = task_run_id
+
                     with self._observed_completed_task_runs_lock:
-                        # Cache the task run ID for a short period of time to avoid
+                        # Cache the state for a short period of time to avoid
                         # unnecessary waits
-                        self._observed_completed_task_runs[task_run_id] = True
+                        self._observed_completed_task_runs[task_run_id] = state_data
                     with self._completion_events_lock:
                         # Set the event for the task run ID if it is in the cache
                         # so the waiter can wake up the waiting coroutine
@@ -162,9 +175,9 @@ class TaskRunWaiter:
     @classmethod
     async def wait_for_task_run(
         cls, task_run_id: uuid.UUID, timeout: Optional[float] = None
-    ) -> None:
+    ) -> Optional[State[Any]]:
         """
-        Wait for a task run to finish.
+        Wait for a task run to finish and return its final state.
 
         Note this relies on a websocket connection to receive events from the server
         and will not work with an ephemeral server.
@@ -173,11 +186,14 @@ class TaskRunWaiter:
             task_run_id: The ID of the task run to wait for.
             timeout: The maximum time to wait for the task run to
                 finish. Defaults to None.
+
+        Returns:
+            The final state of the task run if available, None otherwise.
         """
         instance = cls.instance()
         with instance._observed_completed_task_runs_lock:
             if task_run_id in instance._observed_completed_task_runs:
-                return
+                return instance._observed_completed_task_runs[task_run_id]
 
         # Need to create event in loop thread to ensure it can be set
         # from the loop thread
@@ -194,12 +210,16 @@ class TaskRunWaiter:
             # wait on it, in case it came in while we were setting up the event above.
             with instance._observed_completed_task_runs_lock:
                 if task_run_id in instance._observed_completed_task_runs:
-                    return
+                    return instance._observed_completed_task_runs[task_run_id]
 
             with anyio.move_on_after(delay=timeout):
                 await from_async.wait_for_call_in_loop_thread(
                     create_call(finished_event.wait)
                 )
+
+            # After waiting, retrieve the state from the cache
+            with instance._observed_completed_task_runs_lock:
+                return instance._observed_completed_task_runs.get(task_run_id)
         finally:
             with instance._completion_events_lock:
                 # Remove the event from the cache after it has been waited on

prefect_client-3.4.16.dev4/src/prefect/_build_info.py

@@ -1,5 +0,0 @@
-# Generated by versioningit
-__version__ = "3.4.16.dev4"
-__build_date__ = "2025-09-03 08:08:47.126346+00:00"
-__git_commit__ = "b0ee987aaf22b3b4e1d0268b7813f1a3fafbda50"
-__dirty__ = False