prefect-client 3.0.10__py3-none-any.whl → 3.0.11__py3-none-any.whl

prefect/settings/models/cloud.py

@@ -0,0 +1,58 @@
+import re
+from typing import Optional
+
+from pydantic import Field, model_validator
+from pydantic_settings import SettingsConfigDict
+from typing_extensions import Self
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+def default_cloud_ui_url(settings: "CloudSettings") -> Optional[str]:
+    value = settings.ui_url
+    if value is not None:
+        return value
+
+    # Otherwise, infer a value from the API URL
+    ui_url = api_url = settings.api_url
+
+    if re.match(r"^https://api[\.\w]*.prefect.[^\.]+/", api_url):
+        ui_url = ui_url.replace("https://api", "https://app", 1)
+
+    if ui_url.endswith("/api"):
+        ui_url = ui_url[:-4]
+
+    return ui_url
+
+
+class CloudSettings(PrefectBaseSettings):
+    """
+    Settings for interacting with Prefect Cloud
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_CLOUD_", env_file=".env", extra="ignore"
+    )
+
+    api_url: str = Field(
+        default="https://api.prefect.cloud/api",
+        description="API URL for Prefect Cloud. Used for authentication with Prefect Cloud.",
+    )
+
+    ui_url: Optional[str] = Field(
+        default=None,
+        description="The URL of the Prefect Cloud UI. If not set, the client will attempt to infer it.",
+    )
+
+    @model_validator(mode="after")
+    def post_hoc_settings(self) -> Self:
+        """refactor on resolution of https://github.com/pydantic/pydantic/issues/9789
+
+        we should not be modifying __pydantic_fields_set__ directly, but until we can
+        define dependencies between defaults in a first-class way, we need clean up
+        post-hoc default assignments to keep set/unset fields correct after instantiation.
+        """
+        if self.ui_url is None:
+            self.ui_url = default_cloud_ui_url(self)
+            self.__pydantic_fields_set__.remove("ui_url")
+        return self

prefect/settings/models/deployments.py

@@ -0,0 +1,40 @@
+from typing import Optional
+
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class DeploymentsSettings(PrefectBaseSettings):
+    """
+    Settings for configuring deployments defaults
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_DEPLOYMENTS_", env_file=".env", extra="ignore"
+    )
+
+    default_work_pool_name: Optional[str] = Field(
+        default=None,
+        description="The default work pool to use when creating deployments.",
+        validation_alias=AliasChoices(
+            AliasPath("default_work_pool_name"),
+            "prefect_deployments_default_work_pool_name",
+            "prefect_default_work_pool_name",
+        ),
+    )
+
+    default_docker_build_namespace: Optional[str] = Field(
+        default=None,
+        description="The default Docker namespace to use when building images.",
+        validation_alias=AliasChoices(
+            AliasPath("default_docker_build_namespace"),
+            "prefect_deployments_default_docker_build_namespace",
+            "prefect_default_docker_build_namespace",
+        ),
+        examples=[
+            "my-dockerhub-registry",
+            "4999999999999.dkr.ecr.us-east-2.amazonaws.com/my-ecr-repo",
+        ],
+    )

prefect/settings/models/flows.py

@@ -0,0 +1,37 @@
+from typing import Union
+
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class FlowsSettings(PrefectBaseSettings):
+    """
+    Settings for controlling flow behavior
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_FLOWS_", env_file=".env", extra="ignore"
+    )
+
+    default_retries: int = Field(
+        default=0,
+        ge=0,
+        description="This value sets the default number of retries for all flows.",
+        validation_alias=AliasChoices(
+            AliasPath("default_retries"),
+            "prefect_flows_default_retries",
+            "prefect_flow_default_retries",
+        ),
+    )
+
+    default_retry_delay_seconds: Union[int, float, list[float]] = Field(
+        default=0,
+        description="This value sets the default retry delay seconds for all flows.",
+        validation_alias=AliasChoices(
+            AliasPath("default_retry_delay_seconds"),
+            "prefect_flows_default_retry_delay_seconds",
+            "prefect_flow_default_retry_delay_seconds",
+        ),
+    )

prefect/settings/models/internal.py

@@ -0,0 +1,21 @@
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+from prefect.types import LogLevel
+
+
+class InternalSettings(PrefectBaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_INTERNAL_", env_file=".env", extra="ignore"
+    )
+
+    logging_level: LogLevel = Field(
+        default="ERROR",
+        description="The default logging level for Prefect's internal machinery loggers.",
+        validation_alias=AliasChoices(
+            AliasPath("logging_level"),
+            "prefect_internal_logging_level",
+            "prefect_logging_internal_level",
+        ),
+    )

prefect/settings/models/logging.py

@@ -0,0 +1,137 @@
+from pathlib import Path
+from typing import Annotated, Literal, Optional, Union
+
+from pydantic import AfterValidator, AliasChoices, AliasPath, Field, model_validator
+from pydantic_settings import SettingsConfigDict
+from typing_extensions import Self
+
+from prefect.settings.base import PrefectBaseSettings
+from prefect.types import LogLevel
+
+
+def max_log_size_smaller_than_batch_size(values):
+    """
+    Validator for settings asserting the batch size and match log size are compatible
+    """
+    if values["batch_size"] < values["max_log_size"]:
+        raise ValueError(
+            "`PREFECT_LOGGING_TO_API_MAX_LOG_SIZE` cannot be larger than"
+            " `PREFECT_LOGGING_TO_API_BATCH_SIZE`"
+        )
+    return values
+
+
+class LoggingToAPISettings(PrefectBaseSettings):
+    """
+    Settings for controlling logging to the API
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_LOGGING_TO_API_", env_file=".env", extra="ignore"
+    )
+
+    enabled: bool = Field(
+        default=True,
+        description="If `True`, logs will be sent to the API.",
+    )
+
+    batch_interval: float = Field(
+        default=2.0,
+        description="The number of seconds between batched writes of logs to the API.",
+    )
+
+    batch_size: int = Field(
+        default=4_000_000,
+        description="The number of logs to batch before sending to the API.",
+    )
+
+    max_log_size: int = Field(
+        default=1_000_000,
+        description="The maximum size in bytes for a single log.",
+    )
+
+    when_missing_flow: Literal["warn", "error", "ignore"] = Field(
+        default="warn",
+        description="""
+        Controls the behavior when loggers attempt to send logs to the API handler from outside of a flow.
+        
+        All logs sent to the API must be associated with a flow run. The API log handler can
+        only be used outside of a flow by manually providing a flow run identifier. Logs
+        that are not associated with a flow run will not be sent to the API. This setting can
+        be used to determine if a warning or error is displayed when the identifier is missing.
+
+        The following options are available:
+
+        - "warn": Log a warning message.
+        - "error": Raise an error.
+        - "ignore": Do not log a warning message or raise an error.
+        """,
+    )
+
+    @model_validator(mode="after")
+    def emit_warnings(self) -> Self:
+        """Emits warnings for misconfiguration of logging settings."""
+        values = self.model_dump()
+        values = max_log_size_smaller_than_batch_size(values)
+        return self
+
+
+class LoggingSettings(PrefectBaseSettings):
+    """
+    Settings for controlling logging behavior
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_LOGGING_", env_file=".env", extra="ignore"
+    )
+
+    level: LogLevel = Field(
+        default="INFO",
+        description="The default logging level for Prefect loggers.",
+    )
+
+    config_path: Optional[Path] = Field(
+        default=None,
+        description="The path to a custom YAML logging configuration file.",
+        validation_alias=AliasChoices(
+            AliasPath("config_path"),
+            "prefect_logging_config_path",
+            "prefect_logging_settings_path",
+        ),
+    )
+
+    extra_loggers: Annotated[
+        Union[str, list[str], None],
+        AfterValidator(lambda v: [n.strip() for n in v.split(",")] if v else []),
+    ] = Field(
+        default=None,
+        description="Additional loggers to attach to Prefect logging at runtime.",
+    )
+
+    log_prints: bool = Field(
+        default=False,
+        description="If `True`, `print` statements in flows and tasks will be redirected to the Prefect logger for the given run.",
+    )
+
+    colors: bool = Field(
+        default=True,
+        description="If `True`, use colors in CLI output. If `False`, output will not include colors codes.",
+    )
+
+    markup: bool = Field(
+        default=False,
+        description="""
+        Whether to interpret strings wrapped in square brackets as a style.
+        This allows styles to be conveniently added to log messages, e.g.
+        `[red]This is a red message.[/red]`. However, the downside is, if enabled,
+        strings that contain square brackets may be inaccurately interpreted and
+        lead to incomplete output, e.g.
+        `[red]This is a red message.[/red]` may be interpreted as
+        `[red]This is a red message.[/red]`.
+        """,
+    )
+
+    to_api: LoggingToAPISettings = Field(
+        default_factory=LoggingToAPISettings,
+        description="Settings for controlling logging to the API",
+    )

prefect/settings/models/results.py

@@ -0,0 +1,47 @@
+from pathlib import Path
+from typing import Optional
+
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class ResultsSettings(PrefectBaseSettings):
+    """
+    Settings for controlling result storage behavior
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_RESULTS_", env_file=".env", extra="ignore"
+    )
+
+    default_serializer: str = Field(
+        default="pickle",
+        description="The default serializer to use when not otherwise specified.",
+    )
+
+    persist_by_default: bool = Field(
+        default=False,
+        description="The default setting for persisting results when not otherwise specified.",
+    )
+
+    default_storage_block: Optional[str] = Field(
+        default=None,
+        description="The `block-type/block-document` slug of a block to use as the default result storage.",
+        validation_alias=AliasChoices(
+            AliasPath("default_storage_block"),
+            "prefect_results_default_storage_block",
+            "prefect_default_result_storage_block",
+        ),
+    )
+
+    local_storage_path: Optional[Path] = Field(
+        default=None,
+        description="The path to a directory to store results in.",
+        validation_alias=AliasChoices(
+            AliasPath("local_storage_path"),
+            "prefect_results_local_storage_path",
+            "prefect_local_storage_path",
+        ),
+    )