prefect-client 3.1.4__py3-none-any.whl → 3.1.6__py3-none-any.whl

prefect/logging/configuration.py

@@ -58,7 +58,7 @@ def load_logging_config(path: Path) -> dict:
     return flatdict_to_dict(flat_config)
 
 
-def setup_logging(incremental: Optional[bool] = None) -> dict:
+def setup_logging(incremental: Optional[bool] = None) -> dict[str, Any]:
     """
     Sets up logging.
 

prefect/logging/highlighters.py

@@ -45,8 +45,7 @@ class StateHighlighter(RegexHighlighter):
 
     base_style = "state."
     highlights = [
-        rf"(?P<{state.value.lower()}_state>{state.value.title()})"
-        for state in StateType
+        rf"(?P<{state.lower()}_state>{state.title()})" for state in StateType
     ] + [
         r"(?P<cached_state>Cached)(?=\(type=COMPLETED\))"  # Highlight only "Cached"
     ]

prefect/logging/loggers.py

@@ -4,12 +4,11 @@ import sys
 from builtins import print
 from contextlib import contextmanager
 from functools import lru_cache
-from logging import LoggerAdapter, LogRecord
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from logging import LogRecord
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from typing_extensions import Self
 
-import prefect
 from prefect.exceptions import MissingContextError
 from prefect.logging.filters import ObfuscateApiKeyFilter
 from prefect.telemetry.logging import add_telemetry_log_handler
@@ -22,8 +21,13 @@ if TYPE_CHECKING:
     from prefect.tasks import Task
     from prefect.workers.base import BaseWorker
 
+if sys.version_info >= (3, 12):
+    LoggingAdapter = logging.LoggerAdapter[logging.Logger]
+else:
+    LoggingAdapter = logging.LoggerAdapter
 
-class PrefectLogAdapter(logging.LoggerAdapter):
+
+class PrefectLogAdapter(LoggingAdapter):
     """
     Adapter that ensures extra kwargs are passed through correctly; without this
     the `extra` fields set on the adapter would overshadow any provided on a
@@ -83,8 +87,8 @@ def get_logger(name: Optional[str] = None) -> logging.Logger:
 
 
 def get_run_logger(
-    context: Optional["RunContext"] = None, **kwargs: str
-) -> Union[logging.Logger, logging.LoggerAdapter]:
+    context: Optional["RunContext"] = None, **kwargs: Any
+) -> Union[logging.Logger, LoggingAdapter]:
     """
     Get a Prefect logger for the current task run or flow run.
 
@@ -103,15 +107,17 @@ def get_run_logger(
     Raises:
         MissingContextError: If no context can be found
     """
+    from prefect.context import FlowRunContext, TaskRunContext
+
     # Check for existing contexts
-    task_run_context = prefect.context.TaskRunContext.get()
-    flow_run_context = prefect.context.FlowRunContext.get()
+    task_run_context = TaskRunContext.get()
+    flow_run_context = FlowRunContext.get()
 
     # Apply the context override
     if context:
-        if isinstance(context, prefect.context.FlowRunContext):
+        if isinstance(context, FlowRunContext):
             flow_run_context = context
-        elif isinstance(context, prefect.context.TaskRunContext):
+        elif isinstance(context, TaskRunContext):
             task_run_context = context
         else:
             raise TypeError(
@@ -130,7 +136,9 @@ def get_run_logger(
         )
     elif flow_run_context:
         logger = flow_run_logger(
-            flow_run=flow_run_context.flow_run, flow=flow_run_context.flow, **kwargs
+            flow_run=flow_run_context.flow_run,  # type: ignore
+            flow=flow_run_context.flow,
+            **kwargs,
         )
     elif (
         get_logger("prefect.flow_run").disabled
@@ -151,9 +159,9 @@ def get_run_logger(
 
 def flow_run_logger(
     flow_run: Union["FlowRun", "ClientFlowRun"],
-    flow: Optional["Flow"] = None,
+    flow: Optional["Flow[Any, Any]"] = None,
     **kwargs: str,
-) -> LoggerAdapter:
+) -> LoggingAdapter:
     """
     Create a flow run logger with the run's metadata attached.
 
@@ -177,10 +185,10 @@ def flow_run_logger(
 
 def task_run_logger(
     task_run: "TaskRun",
-    task: "Task" = None,
-    flow_run: "FlowRun" = None,
-    flow: "Flow" = None,
-    **kwargs: str,
+    task: Optional["Task[Any, Any]"] = None,
+    flow_run: Optional["FlowRun"] = None,
+    flow: Optional["Flow[Any, Any]"] = None,
+    **kwargs: Any,
 ):
     """
     Create a task run logger with the run's metadata attached.
@@ -193,8 +201,10 @@ def task_run_logger(
     If only the flow run context is available, it will be used for default values
     of `flow_run` and `flow`.
     """
+    from prefect.context import FlowRunContext
+
     if not flow_run or not flow:
-        flow_run_context = prefect.context.FlowRunContext.get()
+        flow_run_context = FlowRunContext.get()
         if flow_run_context:
             flow_run = flow_run or flow_run_context.flow_run
             flow = flow or flow_run_context.flow
@@ -269,7 +279,7 @@ def disable_run_logger():
         yield
 
 
-def print_as_log(*args, **kwargs):
+def print_as_log(*args: Any, **kwargs: Any) -> None:
     """
     A patch for `print` to send printed messages to the Prefect run logger.
 
@@ -333,7 +343,7 @@ class LogEavesdropper(logging.Handler):
         # Outputs: "Hello, world!\nAnother one!"
     """
 
-    _target_logger: logging.Logger
+    _target_logger: Optional[logging.Logger]
     _lines: List[str]
 
     def __init__(self, eavesdrop_on: str, level: int = logging.NOTSET):

prefect/main.py

@@ -1,16 +1,18 @@
 # Import user-facing API
+from typing import Any
+
 from prefect.deployments import deploy
 from prefect.states import State
 from prefect.logging import get_run_logger
-from prefect.flows import flow, Flow, serve
+from prefect.flows import flow, Flow, serve, aserve
 from prefect.transactions import Transaction
 from prefect.tasks import task, Task
 from prefect.context import tags
 from prefect.utilities.annotations import unmapped, allow_failure
 from prefect.results import BaseResult, ResultRecordMetadata
 from prefect.flow_runs import pause_flow_run, resume_flow_run, suspend_flow_run
-from prefect.client.orchestration import get_client, PrefectClient
-from prefect.client.cloud import get_cloud_client, CloudClient
+from prefect.client.orchestration import get_client
+from prefect.client.cloud import get_cloud_client
 import prefect.variables
 import prefect.runtime
 
@@ -25,28 +27,17 @@ import prefect.context
 # Perform any forward-ref updates needed for Pydantic models
 import prefect.client.schemas
 
-prefect.context.FlowRunContext.model_rebuild(
-    _types_namespace={
-        "Flow": Flow,
-        "BaseResult": BaseResult,
-        "ResultRecordMetadata": ResultRecordMetadata,
-    }
-)
-prefect.context.TaskRunContext.model_rebuild(
-    _types_namespace={"Task": Task, "BaseResult": BaseResult}
-)
-prefect.client.schemas.State.model_rebuild(
-    _types_namespace={
-        "BaseResult": BaseResult,
-        "ResultRecordMetadata": ResultRecordMetadata,
-    }
-)
-prefect.client.schemas.StateCreate.model_rebuild(
-    _types_namespace={
-        "BaseResult": BaseResult,
-        "ResultRecordMetadata": ResultRecordMetadata,
-    }
+_types: dict[str, Any] = dict(
+    Task=Task,
+    Flow=Flow,
+    BaseResult=BaseResult,
+    ResultRecordMetadata=ResultRecordMetadata,
 )
+prefect.context.FlowRunContext.model_rebuild(_types_namespace=_types)
+prefect.context.TaskRunContext.model_rebuild(_types_namespace=_types)
+prefect.client.schemas.State.model_rebuild(_types_namespace=_types)
+prefect.client.schemas.StateCreate.model_rebuild(_types_namespace=_types)
+prefect.client.schemas.OrchestrationResult.model_rebuild(_types_namespace=_types)
 Transaction.model_rebuild()
 
 # Configure logging
@@ -76,6 +67,7 @@ __all__ = [
     "flow",
     "Flow",
     "get_client",
+    "get_cloud_client",
     "get_run_logger",
     "State",
     "tags",
@@ -84,6 +76,7 @@ __all__ = [
     "Transaction",
     "unmapped",
     "serve",
+    "aserve",
     "deploy",
     "pause_flow_run",
     "resume_flow_run",

prefect/runner/runner.py

@@ -43,7 +43,17 @@ import threading
 from copy import deepcopy
 from functools import partial
 from pathlib import Path
-from typing import TYPE_CHECKING, Callable, Dict, Iterable, List, Optional, Set, Union
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Set,
+    Union,
+)
 from uuid import UUID, uuid4
 
 import anyio
@@ -190,7 +200,7 @@ class Runner:
         self._cancelling_flow_run_ids = set()
         self._scheduled_task_scopes = set()
         self._deployment_ids: Set[UUID] = set()
-        self._flow_run_process_map: Dict[UUID, Dict] = dict()
+        self._flow_run_process_map: dict[UUID, dict[str, Any]] = dict()
 
         self._tmp_dir: Path = (
             Path(tempfile.gettempdir()) / "runner_storage" / str(uuid4())
@@ -432,10 +442,14 @@ class Runner:
                     )
                 )
 
-    def execute_in_background(self, func, *args, **kwargs):
+    def execute_in_background(
+        self, func: Callable[..., Any], *args: Any, **kwargs: Any
+    ):
         """
         Executes a function in the background.
         """
+        if TYPE_CHECKING:
+            assert self._loop is not None
 
         return asyncio.run_coroutine_threadsafe(func(*args, **kwargs), self._loop)
 
@@ -536,7 +550,7 @@ class Runner:
     async def _run_process(
         self,
         flow_run: "FlowRun",
-        task_status: Optional[anyio.abc.TaskStatus] = None,
+        task_status: Optional[anyio.abc.TaskStatus[Any]] = None,
         entrypoint: Optional[str] = None,
     ):
         """
@@ -723,7 +737,9 @@ class Runner:
         return await self._submit_scheduled_flow_runs(flow_run_response=runs_response)
 
     async def _check_for_cancelled_flow_runs(
-        self, should_stop: Callable = lambda: False, on_stop: Callable = lambda: None
+        self,
+        should_stop: Callable[[], bool] = lambda: False,
+        on_stop: Callable[[], None] = lambda: None,
     ):
         """
         Checks for flow runs with CANCELLING a cancelling state and attempts to
@@ -862,31 +878,37 @@ class Runner:
         flow: "Optional[APIFlow]",
         deployment: "Optional[Deployment]",
     ):
-        related = []
-        tags = []
+        related: list[RelatedResource] = []
+        tags: list[str] = []
         if deployment:
             related.append(
-                {
-                    "prefect.resource.id": f"prefect.deployment.{deployment.id}",
-                    "prefect.resource.role": "deployment",
-                    "prefect.resource.name": deployment.name,
-                }
+                RelatedResource(
+                    {
+                        "prefect.resource.id": f"prefect.deployment.{deployment.id}",
+                        "prefect.resource.role": "deployment",
+                        "prefect.resource.name": deployment.name,
+                    }
+                )
             )
             tags.extend(deployment.tags)
         if flow:
             related.append(
+                RelatedResource(
+                    {
+                        "prefect.resource.id": f"prefect.flow.{flow.id}",
+                        "prefect.resource.role": "flow",
+                        "prefect.resource.name": flow.name,
+                    }
+                )
+            )
+        related.append(
+            RelatedResource(
                 {
-                    "prefect.resource.id": f"prefect.flow.{flow.id}",
-                    "prefect.resource.role": "flow",
-                    "prefect.resource.name": flow.name,
+                    "prefect.resource.id": f"prefect.flow-run.{flow_run.id}",
+                    "prefect.resource.role": "flow-run",
+                    "prefect.resource.name": flow_run.name,
                 }
             )
-        related.append(
-            {
-                "prefect.resource.id": f"prefect.flow-run.{flow_run.id}",
-                "prefect.resource.role": "flow-run",
-                "prefect.resource.name": flow_run.name,
-            }
         )
         tags.extend(flow_run.tags)
 

prefect/runner/server.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
+from typing import TYPE_CHECKING, Any, Callable, Coroutine, Hashable, Optional, Tuple
 
 import pendulum
 import uvicorn
@@ -22,7 +22,7 @@ from prefect.settings import (
     PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE,
     PREFECT_RUNNER_SERVER_PORT,
 )
-from prefect.utilities.asyncutils import sync_compatible
+from prefect.utilities.asyncutils import run_coro_as_sync
 from prefect.utilities.importtools import load_script_as_module
 
 if TYPE_CHECKING:
@@ -38,11 +38,13 @@ RunnableEndpoint = Literal["deployment", "flow", "task"]
 
 class RunnerGenericFlowRunRequest(BaseModel):
     entrypoint: str
-    parameters: Optional[Dict[str, Any]] = None
+    parameters: Optional[dict[str, Any]] = None
     parent_task_run_id: Optional[uuid.UUID] = None
 
 
-def perform_health_check(runner, delay_threshold: Optional[int] = None) -> JSONResponse:
+def perform_health_check(
+    runner: "Runner", delay_threshold: Optional[int] = None
+) -> Callable[..., JSONResponse]:
     if delay_threshold is None:
         delay_threshold = (
             PREFECT_RUNNER_SERVER_MISSED_POLLS_TOLERANCE.value()
@@ -63,15 +65,15 @@ def perform_health_check(runner, delay_threshold: Optional[int] = None) -> JSONR
     return _health_check
 
 
-def run_count(runner) -> int:
-    def _run_count():
-        run_count = len(runner._flow_run_process_map)
+def run_count(runner: "Runner") -> Callable[..., int]:
+    def _run_count() -> int:
+        run_count = len(runner._flow_run_process_map)  # pyright: ignore[reportPrivateUsage]
         return run_count
 
     return _run_count
 
 
-def shutdown(runner) -> int:
+def shutdown(runner: "Runner") -> Callable[..., JSONResponse]:
     def _shutdown():
         runner.stop()
         return JSONResponse(status_code=status.HTTP_200_OK, content={"message": "OK"})
@@ -81,9 +83,9 @@ def shutdown(runner) -> int:
 
 async def _build_endpoint_for_deployment(
     deployment: "DeploymentResponse", runner: "Runner"
-) -> Callable:
+) -> Callable[..., Coroutine[Any, Any, JSONResponse]]:
     async def _create_flow_run_for_deployment(
-        body: Optional[Dict[Any, Any]] = None,
+        body: Optional[dict[Any, Any]] = None,
     ) -> JSONResponse:
         body = body or {}
         if deployment.enforce_parameter_schema and deployment.parameter_openapi_schema:
@@ -116,11 +118,11 @@ async def _build_endpoint_for_deployment(
 
 async def get_deployment_router(
     runner: "Runner",
-) -> Tuple[APIRouter, Dict[str, Dict]]:
+) -> Tuple[APIRouter, dict[Hashable, Any]]:
     router = APIRouter()
-    schemas = {}
+    schemas: dict[Hashable, Any] = {}
     async with get_client() as client:
-        for deployment_id in runner._deployment_ids:
+        for deployment_id in runner._deployment_ids:  # pyright: ignore[reportPrivateUsage]
             deployment = await client.read_deployment(deployment_id)
             router.add_api_route(
                 f"/deployment/{deployment.id}/run",
@@ -142,21 +144,21 @@ async def get_deployment_router(
     return router, schemas
 
 
-async def get_subflow_schemas(runner: "Runner") -> Dict[str, Dict]:
+async def get_subflow_schemas(runner: "Runner") -> dict[str, dict[str, Any]]:
     """
     Load available subflow schemas by filtering for only those subflows in the
     deployment entrypoint's import space.
     """
-    schemas = {}
+    schemas: dict[str, dict[str, Any]] = {}
     async with get_client() as client:
-        for deployment_id in runner._deployment_ids:
+        for deployment_id in runner._deployment_ids:  # pyright: ignore[reportPrivateUsage]
             deployment = await client.read_deployment(deployment_id)
             if deployment.entrypoint is None:
                 continue
 
             script = deployment.entrypoint.split(":")[0]
             module = load_script_as_module(script)
-            subflows = [
+            subflows: list[Flow[Any, Any]] = [
                 obj for obj in module.__dict__.values() if isinstance(obj, Flow)
             ]
             for flow in subflows:
@@ -165,7 +167,7 @@ async def get_subflow_schemas(runner: "Runner") -> Dict[str, Dict]:
     return schemas
 
 
-def _flow_in_schemas(flow: Flow, schemas: Dict[str, Dict]) -> bool:
+def _flow_in_schemas(flow: Flow[Any, Any], schemas: dict[str, dict[str, Any]]) -> bool:
     """
     Check if a flow is in the schemas dict, either by name or by name with
     dashes replaced with underscores.
@@ -174,7 +176,9 @@ def _flow_in_schemas(flow: Flow, schemas: Dict[str, Dict]) -> bool:
     return flow.name in schemas or flow_name_with_dashes in schemas
 
 
-def _flow_schema_changed(flow: Flow, schemas: Dict[str, Dict]) -> bool:
+def _flow_schema_changed(
+    flow: Flow[Any, Any], schemas: dict[str, dict[str, Any]]
+) -> bool:
     """
     Check if a flow's schemas have changed, either by bame of by name with
     dashes replaced with underscores.
@@ -188,8 +192,8 @@ def _flow_schema_changed(flow: Flow, schemas: Dict[str, Dict]) -> bool:
 
 
 def _build_generic_endpoint_for_flows(
-    runner: "Runner", schemas: Dict[str, Dict]
-) -> Callable:
+    runner: "Runner", schemas: dict[str, dict[str, Any]]
+) -> Callable[..., Coroutine[Any, Any, JSONResponse]]:
     async def _create_flow_run_for_flow_from_fqn(
         body: RunnerGenericFlowRunRequest,
     ) -> JSONResponse:
@@ -241,7 +245,6 @@ def _build_generic_endpoint_for_flows(
     return _create_flow_run_for_flow_from_fqn
 
 
-@sync_compatible
 async def build_server(runner: "Runner") -> FastAPI:
     """
     Build a FastAPI server for a runner.
@@ -297,16 +300,11 @@ def start_webserver(runner: "Runner", log_level: Optional[str] = None) -> None:
     host = PREFECT_RUNNER_SERVER_HOST.value()
     port = PREFECT_RUNNER_SERVER_PORT.value()
     log_level = log_level or PREFECT_RUNNER_SERVER_LOG_LEVEL.value()
-    webserver = build_server(runner)
+    webserver = run_coro_as_sync(build_server(runner))
+    if TYPE_CHECKING:
+        assert webserver is not None, "webserver should be built"
+        assert log_level is not None, "log_level should be set"
+
     uvicorn.run(
         webserver, host=host, port=port, log_level=log_level.lower()
     )  # Uvicorn supports only lowercase log_level
-    # From the Uvicorn config file:
-    # LOG_LEVELS: dict[str, int] = {
-    #     "critical": logging.CRITICAL,
-    #     "error": logging.ERROR,
-    #     "warning": logging.WARNING,
-    #     "info": logging.INFO,
-    #     "debug": logging.DEBUG,
-    #     "trace": TRACE_LOG_LEVEL,
-    # }

prefect/runner/submit.py

@@ -42,11 +42,8 @@ async def _submit_flow_to_runner(
     Returns:
         A `FlowRun` object representing the flow run that was submitted.
     """
-    from prefect.utilities.engine import (
-        _dynamic_key_for_task_run,
-        collect_task_run_inputs,
-        resolve_inputs,
-    )
+    from prefect.utilities._engine import dynamic_key_for_task_run
+    from prefect.utilities.engine import collect_task_run_inputs, resolve_inputs
 
     async with get_client() as client:
         if not retry_failed_submissions:
@@ -67,7 +64,7 @@ async def _submit_flow_to_runner(
                 parent_flow_run_context.flow_run.id if parent_flow_run_context else None
             ),
             dynamic_key=(
-                _dynamic_key_for_task_run(parent_flow_run_context, dummy_task)
+                dynamic_key_for_task_run(parent_flow_run_context, dummy_task)
                 if parent_flow_run_context
                 else str(uuid.uuid4())
             ),

prefect/runner/utils.py

@@ -1,5 +1,5 @@
 from copy import deepcopy
-from typing import Any, Dict
+from typing import Any
 
 from fastapi import FastAPI
 from fastapi.openapi.utils import get_openapi
@@ -8,8 +8,8 @@ from prefect import __version__ as PREFECT_VERSION
 
 
 def inject_schemas_into_openapi(
-    webserver: FastAPI, schemas_to_inject: Dict[str, Any]
-) -> Dict[str, Any]:
+    webserver: FastAPI, schemas_to_inject: dict[str, Any]
+) -> dict[str, Any]:
     """
     Augments the webserver's OpenAPI schema with additional schemas from deployments / flows / tasks.
 
@@ -29,8 +29,8 @@ def inject_schemas_into_openapi(
 
 
 def merge_definitions(
-    injected_schemas: Dict[str, Any], openapi_schema: Dict[str, Any]
-) -> Dict[str, Any]:
+    injected_schemas: dict[str, Any], openapi_schema: dict[str, Any]
+) -> dict[str, Any]:
     """
     Integrates definitions from injected schemas into the OpenAPI components.
 
@@ -69,7 +69,7 @@ def update_refs_in_schema(schema_item: Any, new_ref: str) -> None:
             update_refs_in_schema(item, new_ref)
 
 
-def update_refs_to_components(openapi_schema: Dict[str, Any]) -> Dict[str, Any]:
+def update_refs_to_components(openapi_schema: dict[str, Any]) -> dict[str, Any]:
     """
     Updates all `$ref` fields in the OpenAPI schema to reference the components section.
 

prefect/runtime/flow_run.py

@@ -44,6 +44,7 @@ __all__ = [
     "run_count",
     "api_url",
     "ui_url",
+    "job_variables",
 ]
 
 
@@ -317,6 +318,11 @@ def get_flow_run_ui_url() -> Optional[str]:
     return f"{PREFECT_UI_URL.value()}/flow-runs/flow-run/{flow_run_id}"
 
 
+def get_job_variables() -> Optional[Dict[str, Any]]:
+    flow_run_ctx = FlowRunContext.get()
+    return flow_run_ctx.flow_run.job_variables if flow_run_ctx else None
+
+
 FIELDS = {
     "id": get_id,
     "tags": get_tags,
@@ -331,4 +337,5 @@ FIELDS = {
     "api_url": get_flow_run_api_url,
     "ui_url": get_flow_run_ui_url,
     "flow_version": get_flow_version,
+    "job_variables": get_job_variables,
 }

prefect/settings/constants.py

@@ -1,8 +1,8 @@
 from pathlib import Path
-from typing import Tuple, Type
+from typing import Any, Tuple, Type
 
 from pydantic import Secret, SecretStr
 
 DEFAULT_PREFECT_HOME = Path.home() / ".prefect"
 DEFAULT_PROFILES_PATH = Path(__file__).parent.joinpath("profiles.toml")
-_SECRET_TYPES: Tuple[Type, ...] = (Secret, SecretStr)
+_SECRET_TYPES: Tuple[Type[Any], ...] = (Secret, SecretStr)

prefect/settings/legacy.py

@@ -8,7 +8,7 @@ from pydantic_settings import BaseSettings
 from typing_extensions import Self
 
 from prefect.settings.base import PrefectBaseSettings
-from prefect.settings.constants import _SECRET_TYPES
+from prefect.settings.constants import _SECRET_TYPES  # type: ignore[reportPrivateUsage]
 from prefect.settings.context import get_current_settings
 from prefect.settings.models.root import Settings
 

prefect/settings/models/server/events.py

@@ -135,3 +135,13 @@ class ServerEventsSettings(PrefectBaseSettings):
             "prefect_messaging_cache",
         ),
     )
+
+    maximum_event_name_length: int = Field(
+        default=1024,
+        gt=0,
+        description="The maximum length of an event name.",
+        validation_alias=AliasChoices(
+            AliasPath("maximum_event_name_length"),
+            "prefect_server_events_maximum_event_name_length",
+        ),
+    )

prefect/settings/sources.py

@@ -121,7 +121,7 @@ class ProfileSettingsTomlLoader(PydanticBaseSettingsSource):
         """Helper method to load the profile settings from the profiles.toml file"""
 
         if not self.profiles_path.exists():
-            return {}
+            return self._get_default_profile()
 
         try:
             all_profile_data = toml.load(self.profiles_path)
@@ -146,9 +146,16 @@ class ProfileSettingsTomlLoader(PydanticBaseSettingsSource):
         profiles_data = all_profile_data.get("profiles", {})
 
         if not active_profile or active_profile not in profiles_data:
-            return {}
+            return self._get_default_profile()
         return profiles_data[active_profile]
 
+    def _get_default_profile(self) -> Dict[str, Any]:
+        """Helper method to get the default profile"""
+        default_profile_data = toml.load(DEFAULT_PROFILES_PATH)
+        default_profile = default_profile_data.get("active", "ephemeral")
+        assert isinstance(default_profile, str)
+        return default_profile_data.get("profiles", {}).get(default_profile, {})
+
     def get_field_value(
         self, field: FieldInfo, field_name: str
     ) -> Tuple[Any, str, bool]: