prefect-client 3.7.3.dev3__tar.gz → 3.7.3.dev5__tar.gz

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/PKG-INFO

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

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/AGENTS.md

@@ -32,6 +32,7 @@ There is no formal public/private boundary beyond the `_` prefix convention. Mod
 - **Nested task submissions on a bounded `ThreadPoolTaskRunner` can deadlock.** When a worker task submits children and blocks on `.result()` while all `max_workers` threads are busy, the pool starves. `_warn_if_nested_submit_would_deadlock` detects this and emits a one-time warning — preserve this detection when changing pool management.
 - **Result storage resolves through three tiers, potentially making an API call.** `get_default_result_storage()` checks: (1) `PREFECT_DEFAULT_RESULT_STORAGE_BLOCK` setting, (2) server-configured default block (API call to the server's Configuration store), (3) local storage path. The API call is silently suppressed on any HTTP error. Engines use `_get_default_persist_result()` — not `should_persist_result()` — at context setup time to auto-enable persistence when a server default block is configured. Do not swap `_get_default_persist_result()` back to `should_persist_result()` in engine initialization paths; `should_persist_result()` does not consult the server default.
 - **`ResultRecordMetadata` tolerates unknown serializer types.** When loading persisted metadata, an unrecognized serializer `type` is converted to an `UnknownSerializer` placeholder rather than raising `ValidationError`. This allows inspecting result metadata when the serializer implementation is unavailable in the current environment. However, known serializer types with invalid fields still raise `ValidationError`. `UnknownSerializer.dumps()` and `UnknownSerializer.loads()` raise `RuntimeError` — the tolerance is for inspection only, not actual serialization/deserialization.
+- **`ResultRecord` must be marked persisted after every storage write.** `ResultStore` calls `mark_persisted()` on every record it writes; `to_state_create` in `states.py` consults `is_persisted` as a fallback when `should_persist_result()` returns `False` (e.g., after run context teardown). Any new sync or async persist path that omits `mark_persisted()` will silently drop state metadata for already-written results.
 - **Flow-run suspension is enforced at orchestration boundaries.** Suspension is delivered via `FlowRunSuspensionRequest` and raised with `raise_if_flow_run_suspension_requested()`. When changing engines, futures, task runners, or generator execution, check before returning control to flow user code or proposing a flow state that could leave `Suspended`; keep sync/async paths aligned and avoid per-boundary API reads.
 
 ## Logging

prefect_client-3.7.3.dev5/src/prefect/_build_info.py

@@ -0,0 +1,5 @@
+# Generated by versioningit
+__version__ = "3.7.3.dev5"
+__build_date__ = "2026-05-28 09:23:34.780141+00:00"
+__git_commit__ = "f7d76f21e9731cedf0462e3f9632133e1c23a439"
+__dirty__ = False

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/_internal/result_records.py

@@ -16,6 +16,7 @@ from uuid import UUID
 from pydantic import (
     BaseModel,
     Field,
+    PrivateAttr,
     ValidationError,
     field_validator,
     model_validator,
@@ -105,6 +106,14 @@ class ResultRecord(BaseModel, Generic[R]):
 
     metadata: ResultRecordMetadata
     result: R
+    _persisted: bool = PrivateAttr(default=False)
+
+    @property
+    def is_persisted(self) -> bool:
+        return self._persisted
+
+    def mark_persisted(self) -> None:
+        self._persisted = True
 
     @property
     def expiration(self) -> DateTime | None:

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/client/orchestration/__init__.py

@@ -137,6 +137,7 @@ from prefect.settings import (
 )
 from prefect.types._datetime import now
 
+from prefect._internal.urls import strip_auth_from_url
 from prefect._internal.version_checking import (
     _api_version_check_key,
     _cache_api_version_check,
@@ -1132,7 +1133,9 @@ class PrefectClient(
         except Exception as e:
             if "Unauthorized" in str(e):
                 raise e
-            raise RuntimeError(f"Failed to reach API at {self.api_url}") from e
+            raise RuntimeError(
+                f"Failed to reach API at {strip_auth_from_url(str(self.api_url))}"
+            ) from e
 
         api_version = version.parse(api_version)
         client_version = version.parse(self.client_version())
@@ -1190,7 +1193,9 @@ class PrefectClient(
                 f"{PREFECT_API_DATABASE_CONNECTION_URL.value()}"
             )
         else:
-            self.logger.debug(f"Connecting to API at {self.api_url}")
+            self.logger.debug(
+                f"Connecting to API at {strip_auth_from_url(str(self.api_url))}"
+            )
 
         # Enter the httpx client's context
         await self._exit_stack.enter_async_context(self._client)
@@ -1519,7 +1524,9 @@ class SyncPrefectClient(
         except Exception as e:
             if "Unauthorized" in str(e):
                 raise e
-            raise RuntimeError(f"Failed to reach API at {self.api_url}") from e
+            raise RuntimeError(
+                f"Failed to reach API at {strip_auth_from_url(str(self.api_url))}"
+            ) from e
 
         api_version = version.parse(api_version)
         client_version = version.parse(self.client_version())

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/results.py

@@ -867,6 +867,7 @@ class ResultStore(BaseModel):
 
         if self.cache_result_in_memory:
             self.cache[resolved_key_path] = result_record
+        result_record.mark_persisted()
         return result_record
 
     def _read(self, key: str, holder: str) -> "ResultRecord[Any]":
@@ -936,6 +937,7 @@ class ResultStore(BaseModel):
 
         if self.cache_result_in_memory:
             self.cache[resolved_key_path] = result_record
+        result_record.mark_persisted()
         return result_record
 
     def read(
@@ -1122,6 +1124,7 @@ class ResultStore(BaseModel):
                 (result_record.metadata.storage_key,),
                 {"content": result_record.serialize()},
             )
+        result_record.mark_persisted()
         if self.cache_result_in_memory:
             self.cache[key] = result_record
 
@@ -1185,6 +1188,7 @@ class ResultStore(BaseModel):
                 (result_record.metadata.storage_key,),
                 {"content": result_record.serialize()},
             )
+        result_record.mark_persisted()
         if self.cache_result_in_memory:
             self.cache[key] = result_record
 

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/runner/AGENTS.md

@@ -138,7 +138,11 @@ These validations exist to prevent git argument injection. Do not bypass them wh
 
 **Env/sys.path isolation:** `_prepared_workspace_context` mutates `os.environ` and `sys.path` in the caller process but does NOT change `os.getcwd()`. The parent working directory is preserved.
 
-**Automatic `uv` command selection:** When no explicit command is passed, `WorkspaceResolvingEngineCommandStarter` auto-selects `uv run --project <project_root> -m prefect.flow_engine` — but only when all three conditions hold: `pyproject.toml` exists at `project_root`, the `project.dependencies` list includes `prefect`, and `uv` is found via the workspace's `PATH` env var (not the system PATH). If any condition fails, the command falls back to `None`. Explicit commands always take precedence.
+**Local path in-place execution:** When no pull steps are configured and the entrypoint file exists at `deployment.path` but not in the workspace root, `prepare_workspace` sets `working_directory` to the local path — not under `workspace_root`. The workspace directory is still created but is not the execution root. This is the "image-baked" pattern: code lives at a fixed local path (e.g., inside a container), not in object storage.
+
+**Pull-step directory fallback:** When pull steps run but none produces a `directory` output or changes CWD, `_ensure_entrypoint_in_workspace` copies storage into the workspace root as a fallback. This handles setup-only pull steps (e.g., `run_shell_script` for environment prep) that do not control the working directory themselves.
+
+**Automatic dependency installation:** By default, `WorkspaceResolvingEngineCommandStarter` does not install dependencies before starting a flow run. When no explicit command is passed and `PREFECT_RUNNER_AUTO_INSTALL_DEPENDENCIES` is true, it auto-selects `uv run --no-default-groups --project <project_root> -m prefect.flow_engine` — but only when all three conditions hold: `pyproject.toml` exists at `project_root`, the `project.dependencies` list includes `prefect`, and `uv` is found via the workspace's `PATH` env var (not the system PATH). If the setting is false or any condition fails, the command falls back to `None`. Explicit commands always take precedence.
 
 ## Reference
 

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/runner/_workspace_resolver.py

@@ -174,6 +174,61 @@ def _workspace_destination_for_deployment_path(
     return (workspace_root / relative_destination).resolve()
 
 
+def _resolve_local_runtime_directory(
+    path: str | None, source_cwd: Path, storage_base_path: Path | None
+) -> Path:
+    resolved_path = _resolve_local_deployment_path(path, source_cwd, storage_base_path)
+    return Path(resolved_path).resolve() if resolved_path is not None else source_cwd
+
+
+def _entrypoint_file_path(entrypoint: str, working_directory: Path) -> Path | None:
+    entrypoint = _resolve_runtime_entrypoint(entrypoint)
+    if ":" not in entrypoint:
+        return None
+
+    path, _object_name = entrypoint.rsplit(":", 1)
+    if not path.endswith(".py"):
+        return None
+
+    entrypoint_path = Path(path).expanduser()
+    if not entrypoint_path.is_absolute():
+        entrypoint_path = working_directory / entrypoint_path
+    return entrypoint_path.resolve()
+
+
+def _has_entrypoint_file(entrypoint: str, working_directory: Path) -> bool:
+    entrypoint_path = _entrypoint_file_path(entrypoint, working_directory)
+    return entrypoint_path is not None and entrypoint_path.is_file()
+
+
+async def _ensure_entrypoint_in_workspace(
+    client: "PrefectClient",
+    deployment: "DeploymentResponse",
+    workspace_root: Path,
+    source_cwd: Path,
+    storage_base_path: Path | None,
+) -> Path:
+    if _has_entrypoint_file(deployment.entrypoint, workspace_root):
+        return workspace_root
+
+    local_runtime_directory = _resolve_local_runtime_directory(
+        deployment.path, source_cwd, storage_base_path
+    )
+    if not deployment.storage_document_id and not _has_entrypoint_file(
+        deployment.entrypoint, local_runtime_directory
+    ):
+        return workspace_root
+
+    await _pull_storage_into_workspace(
+        client,
+        deployment,
+        workspace_root,
+        source_cwd,
+        storage_base_path,
+    )
+    return workspace_root
+
+
 @contextlib.contextmanager
 def _redirect_stdout_to_stderr() -> Any:
     stdout = sys.stdout
@@ -218,9 +273,12 @@ async def _pull_storage_into_workspace(
             else None
         )
     else:
-        from_path = _resolve_local_deployment_path(
+        resolved_local_path = _resolve_local_deployment_path(
             deployment.path, source_cwd, storage_base_path
         )
+        from_path = (
+            resolved_local_path if resolved_local_path is not None else str(source_cwd)
+        )
         storage_block = LocalFileSystem(basepath=from_path)
 
     LOGGER.info("Downloading flow code from storage at %r", from_path)
@@ -253,11 +311,17 @@ async def prepare_workspace(
             source_cwd,
             storage_base_path,
         )
-        os.chdir(working_directory)
-        working_directory = Path.cwd().resolve()
+        local_runtime_directory = _resolve_local_runtime_directory(
+            deployment.path, source_cwd, storage_base_path
+        )
+        if not _has_entrypoint_file(
+            deployment.entrypoint, working_directory
+        ) and _has_entrypoint_file(deployment.entrypoint, local_runtime_directory):
+            working_directory = local_runtime_directory
     else:
+        working_directory = resolved_workspace_root
+        step_selected_working_directory = False
         os.chdir(resolved_workspace_root)
-        working_directory = Path.cwd().resolve()
         LOGGER.info("Running %s deployment pull step(s)", len(deployment.pull_steps))
 
         def _track_step_workspace(
@@ -266,17 +330,19 @@ async def prepare_workspace(
             step_start_cwd: Path | None,
             step_end_cwd: Path | None,
         ) -> None:
-            nonlocal working_directory
+            nonlocal step_selected_working_directory, working_directory
 
             if isinstance(step_output, dict) and step_output.get("directory"):
                 resolved_directory = _resolve_directory_output(
                     step_output, step_end_cwd
                 )
                 if resolved_directory is not None:
+                    step_selected_working_directory = True
                     working_directory = resolved_directory
                 return
 
             if step_end_cwd is not None and step_end_cwd != step_start_cwd:
+                step_selected_working_directory = True
                 working_directory = step_end_cwd
 
         with _observe_step_completion(_track_step_workspace):
@@ -288,6 +354,18 @@ async def prepare_workspace(
                 logger=LOGGER,
             )
 
+        if not step_selected_working_directory:
+            working_directory = await _ensure_entrypoint_in_workspace(
+                client,
+                deployment,
+                resolved_workspace_root,
+                source_cwd,
+                storage_base_path,
+            )
+
+    os.chdir(working_directory)
+    working_directory = Path.cwd().resolve()
+
     project_root = _find_project_root(working_directory, resolved_workspace_root)
     return PreparedWorkspace(
         workspace_root=resolved_workspace_root,

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/runner/_workspace_starter.py

@@ -167,6 +167,9 @@ def _pyproject_declares_prefect_dependency(pyproject: Path) -> bool:
 
 
 def _uv_run_command(workspace: PreparedWorkspace) -> str | None:
+    if not get_current_settings().runner.auto_install_dependencies:
+        return None
+
     project_root = workspace.project_root
     if project_root is None:
         return None
@@ -188,6 +191,7 @@ def _uv_run_command(workspace: PreparedWorkspace) -> str | None:
         [
             uv_executable,
             "run",
+            "--no-default-groups",
             "--project",
             str(project_root),
             "-m",

prefect_client-3.7.3.dev5/src/prefect/server/api/__init__.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import importlib
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from prefect.server.api import (
+        admin,
+        artifacts,
+        automations,
+        block_capabilities,
+        block_documents,
+        block_schemas,
+        block_types,
+        collections,
+        concurrency_limits,
+        concurrency_limits_v2,
+        csrf_token,
+        dependencies,
+        deployments,
+        events,
+        flow_run_states,
+        flow_runs,
+        flows,
+        logs,
+        middleware,
+        root,
+        run_history,
+        saved_searches,
+        server,
+        task_run_states,
+        task_runs,
+        task_workers,
+        templates,
+        ui,
+        variables,
+        work_queues,
+        workers,
+    )
+
+__all__ = [
+    "admin",
+    "artifacts",
+    "automations",
+    "block_capabilities",
+    "block_documents",
+    "block_schemas",
+    "block_types",
+    "collections",
+    "concurrency_limits",
+    "concurrency_limits_v2",
+    "csrf_token",
+    "dependencies",
+    "deployments",
+    "events",
+    "flow_run_states",
+    "flow_runs",
+    "flows",
+    "logs",
+    "middleware",
+    "root",
+    "run_history",
+    "saved_searches",
+    "server",
+    "task_run_states",
+    "task_runs",
+    "task_workers",
+    "templates",
+    "ui",
+    "variables",
+    "work_queues",
+    "workers",
+]
+
+
+def __getattr__(name: str) -> object:
+    module_name = f"{__name__}.{name}"
+    try:
+        module = importlib.import_module(module_name)
+    except ModuleNotFoundError as exc:
+        if exc.name != module_name:
+            raise
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}") from None
+
+    globals()[name] = module
+    return module

prefect_client-3.7.3.dev5/src/prefect/settings/_types.py

@@ -0,0 +1,225 @@
+# This file is generated by `scripts/generate_settings_types.py`.
+# Update the generation script to update this file.
+from typing import Literal, TypeAlias
+
+SettingAccessor: TypeAlias = Literal[
+    "api.auth_string",
+    "api.enable_http2",
+    "api.key",
+    "api.request_timeout",
+    "api.ssl_cert_file",
+    "api.tls_insecure_skip_verify",
+    "api.url",
+    "cli.colors",
+    "cli.prompt",
+    "cli.wrap_lines",
+    "client.csrf_support_enabled",
+    "client.custom_headers",
+    "client.max_retries",
+    "client.metrics.enabled",
+    "client.metrics.port",
+    "client.retry_extra_codes",
+    "client.retry_jitter_factor",
+    "client.server_version_check_enabled",
+    "cloud.api_url",
+    "cloud.enable_orchestration_telemetry",
+    "cloud.max_log_size",
+    "cloud.ui_url",
+    "debug_mode",
+    "deployments.default_docker_build_namespace",
+    "deployments.default_work_pool_name",
+    "events.worker_max_queue_size",
+    "experiments.warn",
+    "flows.default_retries",
+    "flows.default_retry_delay_seconds",
+    "flows.heartbeat_frequency",
+    "home",
+    "internal.logging_level",
+    "logging.colors",
+    "logging.config_path",
+    "logging.extra_loggers",
+    "logging.level",
+    "logging.log_prints",
+    "logging.markup",
+    "logging.to_api.batch_interval",
+    "logging.to_api.batch_size",
+    "logging.to_api.enabled",
+    "logging.to_api.max_log_size",
+    "logging.to_api.when_missing_flow",
+    "plugins.allow",
+    "plugins.deny",
+    "plugins.enabled",
+    "plugins.safe_mode",
+    "plugins.setup_timeout_seconds",
+    "plugins.strict",
+    "profiles_path",
+    "results.default_serializer",
+    "results.default_storage_block",
+    "results.local_storage_path",
+    "results.persist_by_default",
+    "runner.crash_on_cancellation_failure",
+    "runner.poll_frequency",
+    "runner.process_limit",
+    "runner.server.enable",
+    "runner.server.host",
+    "runner.server.log_level",
+    "runner.server.missed_polls_tolerance",
+    "runner.server.port",
+    "server.analytics_enabled",
+    "server.api.auth_string",
+    "server.api.base_path",
+    "server.api.cors_allowed_headers",
+    "server.api.cors_allowed_methods",
+    "server.api.cors_allowed_origins",
+    "server.api.csrf_protection_enabled",
+    "server.api.csrf_token_expiration",
+    "server.api.default_limit",
+    "server.api.host",
+    "server.api.keepalive_timeout",
+    "server.api.max_parameter_size",
+    "server.api.port",
+    "server.api.websocket_ping_interval",
+    "server.api.websocket_ping_timeout",
+    "server.concurrency.initial_deployment_lease_duration",
+    "server.concurrency.lease_storage",
+    "server.concurrency.maximum_concurrency_slot_wait_seconds",
+    "server.database.connection_timeout",
+    "server.database.connection_url",
+    "server.database.driver",
+    "server.database.echo",
+    "server.database.host",
+    "server.database.migrate_on_start",
+    "server.database.name",
+    "server.database.password",
+    "server.database.port",
+    "server.database.sqlalchemy.connect_args.application_name",
+    "server.database.sqlalchemy.connect_args.prepared_statement_cache_size",
+    "server.database.sqlalchemy.connect_args.search_path",
+    "server.database.sqlalchemy.connect_args.statement_cache_size",
+    "server.database.sqlalchemy.connect_args.tls.ca_file",
+    "server.database.sqlalchemy.connect_args.tls.cert_file",
+    "server.database.sqlalchemy.connect_args.tls.check_hostname",
+    "server.database.sqlalchemy.connect_args.tls.enabled",
+    "server.database.sqlalchemy.connect_args.tls.key_file",
+    "server.database.sqlalchemy.max_overflow",
+    "server.database.sqlalchemy.pool_recycle",
+    "server.database.sqlalchemy.pool_size",
+    "server.database.sqlalchemy.pool_timeout",
+    "server.database.timeout",
+    "server.database.user",
+    "server.deployment_schedule_max_scheduled_runs",
+    "server.deployments.concurrency_slot_wait_seconds",
+    "server.docket.name",
+    "server.docket.url",
+    "server.ephemeral.enabled",
+    "server.ephemeral.startup_timeout_seconds",
+    "server.events.causal_ordering",
+    "server.events.expired_bucket_buffer",
+    "server.events.maximum_event_name_length",
+    "server.events.maximum_labels_per_resource",
+    "server.events.maximum_related_resources",
+    "server.events.maximum_size_bytes",
+    "server.events.maximum_websocket_backfill",
+    "server.events.messaging_broker",
+    "server.events.messaging_cache",
+    "server.events.proactive_granularity",
+    "server.events.related_resource_cache_ttl",
+    "server.events.retention_period",
+    "server.events.stream_out_enabled",
+    "server.events.websocket_backfill_page_size",
+    "server.flow_run_graph.max_artifacts",
+    "server.flow_run_graph.max_nodes",
+    "server.log_retryable_errors",
+    "server.logging_level",
+    "server.logs.stream_out_enabled",
+    "server.logs.stream_publishing_enabled",
+    "server.memo_store_path",
+    "server.memoize_block_auto_registration",
+    "server.metrics_enabled",
+    "server.register_blocks_on_start",
+    "server.services.cancellation_cleanup.enabled",
+    "server.services.cancellation_cleanup.loop_seconds",
+    "server.services.db_vacuum.batch_size",
+    "server.services.db_vacuum.enabled",
+    "server.services.db_vacuum.event_retention_overrides",
+    "server.services.db_vacuum.loop_seconds",
+    "server.services.db_vacuum.retention_period",
+    "server.services.event_logger.enabled",
+    "server.services.event_persister.batch_size",
+    "server.services.event_persister.enabled",
+    "server.services.event_persister.flush_interval",
+    "server.services.event_persister.max_flush_retries",
+    "server.services.event_persister.queue_max_size",
+    "server.services.event_persister.read_batch_size",
+    "server.services.foreman.deployment_last_polled_timeout_seconds",
+    "server.services.foreman.enabled",
+    "server.services.foreman.fallback_heartbeat_interval_seconds",
+    "server.services.foreman.inactivity_heartbeat_multiple",
+    "server.services.foreman.loop_seconds",
+    "server.services.foreman.work_queue_last_polled_timeout_seconds",
+    "server.services.late_runs.after_seconds",
+    "server.services.late_runs.enabled",
+    "server.services.late_runs.loop_seconds",
+    "server.services.pause_expirations.enabled",
+    "server.services.pause_expirations.loop_seconds",
+    "server.services.repossessor.enabled",
+    "server.services.repossessor.loop_seconds",
+    "server.services.scheduler.deployment_batch_size",
+    "server.services.scheduler.enabled",
+    "server.services.scheduler.insert_batch_size",
+    "server.services.scheduler.loop_seconds",
+    "server.services.scheduler.max_runs",
+    "server.services.scheduler.max_scheduled_time",
+    "server.services.scheduler.min_runs",
+    "server.services.scheduler.min_scheduled_time",
+    "server.services.scheduler.recent_deployments_loop_seconds",
+    "server.services.task_run_recorder.batch_size",
+    "server.services.task_run_recorder.enabled",
+    "server.services.task_run_recorder.flush_interval",
+    "server.services.task_run_recorder.read_batch_size",
+    "server.services.triggers.enabled",
+    "server.services.triggers.pg_notify_heartbeat_interval_seconds",
+    "server.services.triggers.pg_notify_reconnect_interval_seconds",
+    "server.services.triggers.read_batch_size",
+    "server.tasks.max_cache_key_length",
+    "server.tasks.scheduling.max_retry_queue_size",
+    "server.tasks.scheduling.max_scheduled_queue_size",
+    "server.tasks.scheduling.pending_task_timeout",
+    "server.tasks.tag_concurrency_slot_wait_seconds",
+    "server.ui.api_url",
+    "server.ui.enabled",
+    "server.ui.serve_base",
+    "server.ui.show_promotional_content",
+    "server.ui.static_directory",
+    "server.ui.v2_enabled",
+    "server.worker_channel.cleanup_completed_idempotency_retention_seconds",
+    "server.worker_channel.cleanup_lease_seconds",
+    "server.worker_channel.cleanup_max_delivery_attempts",
+    "server.worker_channel.cleanup_queue_storage",
+    "silence_api_url_misconfiguration",
+    "tasks.default_no_cache",
+    "tasks.default_persist_result",
+    "tasks.default_retries",
+    "tasks.default_retry_delay_seconds",
+    "tasks.disable_caching",
+    "tasks.refresh_cache",
+    "tasks.runner.process_pool_max_workers",
+    "tasks.runner.thread_pool_max_workers",
+    "tasks.scheduling.default_storage_block",
+    "tasks.scheduling.delete_failed_submissions",
+    "telemetry.enable_resource_metrics",
+    "telemetry.resource_metrics_interval_seconds",
+    "testing.test_mode",
+    "testing.test_setting",
+    "testing.unit_test_loop_debug",
+    "testing.unit_test_mode",
+    "ui_url",
+    "worker.cancellation_poll_seconds",
+    "worker.debug_mode",
+    "worker.enable_cancellation",
+    "worker.heartbeat_seconds",
+    "worker.prefetch_seconds",
+    "worker.query_seconds",
+    "worker.webserver.host",
+    "worker.webserver.port",
+]

{prefect_client-3.7.3.dev3 → prefect_client-3.7.3.dev5}/src/prefect/settings/context.py

@@ -4,8 +4,11 @@ from typing import TYPE_CHECKING, Any, Generator, Iterable, Mapping, Optional
 from prefect.settings.models.root import Settings
 
 if TYPE_CHECKING:
+    from prefect.settings._types import SettingAccessor
     from prefect.settings.legacy import Setting
 
+    SettingKey = Setting | SettingAccessor
+
 
 def get_current_settings() -> Settings:
     """
@@ -23,9 +26,9 @@ def get_current_settings() -> Settings:
 
 @contextmanager
 def temporary_settings(
-    updates: Optional[Mapping["Setting", Any]] = None,
-    set_defaults: Optional[Mapping["Setting", Any]] = None,
-    restore_defaults: Optional[Iterable["Setting"]] = None,
+    updates: Optional[Mapping["SettingKey", Any]] = None,
+    set_defaults: Optional[Mapping["SettingKey", Any]] = None,
+    restore_defaults: Optional[Iterable["SettingKey"]] = None,
 ) -> Generator[Settings, None, None]:
     """
     Temporarily override the current settings by entering a new profile.
@@ -40,6 +43,9 @@ def temporary_settings(
         with temporary_settings(updates={PREFECT_API_URL: "foo"}):
            assert PREFECT_API_URL.value() == "foo"
 
+           with temporary_settings(updates={"api.url": "bar"}):
+                assert get_current_settings().api.url == "bar"
+
            with temporary_settings(set_defaults={PREFECT_API_URL: "bar"}):
                 assert PREFECT_API_URL.value() == "foo"