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

prefect/settings/models/server/database.py

@@ -0,0 +1,202 @@
+import warnings
+from typing import Optional
+from urllib.parse import quote_plus
+
+from pydantic import AliasChoices, AliasPath, Field, SecretStr, model_validator
+from pydantic_settings import SettingsConfigDict
+from typing_extensions import Literal, Self
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class ServerDatabaseSettings(PrefectBaseSettings):
+    """
+    Settings for controlling server database behavior
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_SERVER_DATABASE_",
+        env_file=".env",
+        extra="ignore",
+    )
+
+    connection_url: Optional[SecretStr] = Field(
+        default=None,
+        description="""
+        A database connection URL in a SQLAlchemy-compatible
+        format. Prefect currently supports SQLite and Postgres. Note that all
+        Prefect database engines must use an async driver - for SQLite, use
+        `sqlite+aiosqlite` and for Postgres use `postgresql+asyncpg`.
+
+        SQLite in-memory databases can be used by providing the url
+        `sqlite+aiosqlite:///file::memory:?cache=shared&uri=true&check_same_thread=false`,
+        which will allow the database to be accessed by multiple threads. Note
+        that in-memory databases can not be accessed from multiple processes and
+        should only be used for simple tests.
+        """,
+        validation_alias=AliasChoices(
+            AliasPath("connection_url"),
+            "prefect_server_database_connection_url",
+            "prefect_api_database_connection_url",
+        ),
+    )
+
+    driver: Optional[Literal["postgresql+asyncpg", "sqlite+aiosqlite"]] = Field(
+        default=None,
+        description=(
+            "The database driver to use when connecting to the database. "
+            "If not set, the driver will be inferred from the connection URL."
+        ),
+        validation_alias=AliasChoices(
+            AliasPath("driver"),
+            "prefect_server_database_driver",
+            "prefect_api_database_driver",
+        ),
+    )
+
+    host: Optional[str] = Field(
+        default=None,
+        description="The database server host.",
+        validation_alias=AliasChoices(
+            AliasPath("host"),
+            "prefect_server_database_host",
+            "prefect_api_database_host",
+        ),
+    )
+
+    port: Optional[int] = Field(
+        default=None,
+        description="The database server port.",
+        validation_alias=AliasChoices(
+            AliasPath("port"),
+            "prefect_server_database_port",
+            "prefect_api_database_port",
+        ),
+    )
+
+    user: Optional[str] = Field(
+        default=None,
+        description="The user to use when connecting to the database.",
+        validation_alias=AliasChoices(
+            AliasPath("user"),
+            "prefect_server_database_user",
+            "prefect_api_database_user",
+        ),
+    )
+
+    name: Optional[str] = Field(
+        default=None,
+        description="The name of the Prefect database on the remote server, or the path to the database file for SQLite.",
+        validation_alias=AliasChoices(
+            AliasPath("name"),
+            "prefect_server_database_name",
+            "prefect_api_database_name",
+        ),
+    )
+
+    password: Optional[SecretStr] = Field(
+        default=None,
+        description="The password to use when connecting to the database. Should be kept secret.",
+        validation_alias=AliasChoices(
+            AliasPath("password"),
+            "prefect_server_database_password",
+            "prefect_api_database_password",
+        ),
+    )
+
+    echo: bool = Field(
+        default=False,
+        description="If `True`, SQLAlchemy will log all SQL issued to the database. Defaults to `False`.",
+        validation_alias=AliasChoices(
+            AliasPath("echo"),
+            "prefect_server_database_echo",
+            "prefect_api_database_echo",
+        ),
+    )
+
+    migrate_on_start: bool = Field(
+        default=True,
+        description="If `True`, the database will be migrated on application startup.",
+        validation_alias=AliasChoices(
+            AliasPath("migrate_on_start"),
+            "prefect_server_database_migrate_on_start",
+            "prefect_api_database_migrate_on_start",
+        ),
+    )
+
+    timeout: Optional[float] = Field(
+        default=10.0,
+        description="A statement timeout, in seconds, applied to all database interactions made by the API. Defaults to 10 seconds.",
+        validation_alias=AliasChoices(
+            AliasPath("timeout"),
+            "prefect_server_database_timeout",
+            "prefect_api_database_timeout",
+        ),
+    )
+
+    connection_timeout: Optional[float] = Field(
+        default=5,
+        description="A connection timeout, in seconds, applied to database connections. Defaults to `5`.",
+        validation_alias=AliasChoices(
+            AliasPath("connection_timeout"),
+            "prefect_server_database_connection_timeout",
+            "prefect_api_database_connection_timeout",
+        ),
+    )
+
+    sqlalchemy_pool_size: Optional[int] = Field(
+        default=None,
+        description="Controls connection pool size when using a PostgreSQL database with the Prefect API. If not set, the default SQLAlchemy pool size will be used.",
+        validation_alias=AliasChoices(
+            AliasPath("sqlalchemy_pool_size"),
+            "prefect_server_database_sqlalchemy_pool_size",
+            "prefect_sqlalchemy_pool_size",
+        ),
+    )
+
+    sqlalchemy_max_overflow: Optional[int] = Field(
+        default=None,
+        description="Controls maximum overflow of the connection pool when using a PostgreSQL database with the Prefect API. If not set, the default SQLAlchemy maximum overflow value will be used.",
+        validation_alias=AliasChoices(
+            AliasPath("sqlalchemy_max_overflow"),
+            "prefect_server_database_sqlalchemy_max_overflow",
+            "prefect_sqlalchemy_max_overflow",
+        ),
+    )
+
+    @model_validator(mode="after")
+    def emit_warnings(self) -> Self:  # noqa: F821
+        """More post-hoc validation of settings, including warnings for misconfigurations."""
+        warn_on_database_password_value_without_usage(self)
+        return self
+
+
+def warn_on_database_password_value_without_usage(settings: ServerDatabaseSettings):
+    """
+    Validator for settings warning if the database password is set but not used.
+    """
+    db_password = (
+        settings.password.get_secret_value()
+        if isinstance(settings.password, SecretStr)
+        else None
+    )
+    api_db_connection_url = (
+        settings.connection_url.get_secret_value()
+        if isinstance(settings.connection_url, SecretStr)
+        else settings.connection_url
+    )
+
+    if (
+        db_password
+        and api_db_connection_url is not None
+        and "PREFECT_API_DATABASE_PASSWORD" not in api_db_connection_url
+        and "PREFECT_SERVER_DATABASE_PASSWORD" not in api_db_connection_url
+        and db_password not in api_db_connection_url
+        and quote_plus(db_password) not in api_db_connection_url
+    ):
+        warnings.warn(
+            "PREFECT_SERVER_DATABASE_PASSWORD is set but not included in the "
+            "PREFECT_SERVER_DATABASE_CONNECTION_URL. "
+            "The provided password will be ignored."
+        )
+    return settings

prefect/settings/models/server/deployments.py

@@ -0,0 +1,24 @@
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class ServerDeploymentsSettings(PrefectBaseSettings):
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_SERVER_DEPLOYMENTS_", env_file=".env", extra="ignore"
+    )
+
+    concurrency_slot_wait_seconds: float = Field(
+        default=30.0,
+        ge=0.0,
+        description=(
+            "The number of seconds to wait before retrying when a deployment flow run"
+            " cannot secure a concurrency slot from the server."
+        ),
+        validation_alias=AliasChoices(
+            AliasPath("concurrency_slot_wait_seconds"),
+            "prefect_server_deployments_concurrency_slot_wait_seconds",
+            "prefect_deployment_concurrency_slot_wait_seconds",
+        ),
+    )

prefect/settings/models/server/ephemeral.py

@@ -0,0 +1,34 @@
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class ServerEphemeralSettings(PrefectBaseSettings):
+    """
+    Settings for controlling ephemeral server behavior
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_SERVER_EPHEMERAL_", env_file=".env", extra="ignore"
+    )
+
+    enabled: bool = Field(
+        default=False,
+        description="""
+        Controls whether or not a subprocess server can be started when no API URL is provided.
+        """,
+        validation_alias=AliasChoices(
+            AliasPath("enabled"),
+            "prefect_server_ephemeral_enabled",
+            "prefect_server_allow_ephemeral_mode",
+        ),
+    )
+
+    startup_timeout_seconds: int = Field(
+        default=20,
+        description="""
+        The number of seconds to wait for the server to start when ephemeral mode is enabled.
+        Defaults to `10`.
+        """,
+    )

prefect/settings/models/server/events.py

@@ -0,0 +1,140 @@
+from datetime import timedelta
+
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class ServerEventsSettings(PrefectBaseSettings):
+    """
+    Settings for controlling behavior of the events subsystem
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_SERVER_EVENTS_", env_file=".env", extra="ignore"
+    )
+
+    ###########################################################################
+    # Events settings
+
+    stream_out_enabled: bool = Field(
+        default=True,
+        description="Whether or not to stream events out to the API via websockets.",
+        validation_alias=AliasChoices(
+            AliasPath("stream_out_enabled"),
+            "prefect_server_events_stream_out_enabled",
+            "prefect_api_events_stream_out_enabled",
+        ),
+    )
+
+    related_resource_cache_ttl: timedelta = Field(
+        default=timedelta(minutes=5),
+        description="The number of seconds to cache related resources for in the API.",
+        validation_alias=AliasChoices(
+            AliasPath("related_resource_cache_ttl"),
+            "prefect_server_events_related_resource_cache_ttl",
+            "prefect_api_events_related_resource_cache_ttl",
+        ),
+    )
+
+    maximum_labels_per_resource: int = Field(
+        default=500,
+        description="The maximum number of labels a resource may have.",
+        validation_alias=AliasChoices(
+            AliasPath("maximum_labels_per_resource"),
+            "prefect_server_events_maximum_labels_per_resource",
+            "prefect_events_maximum_labels_per_resource",
+        ),
+    )
+
+    maximum_related_resources: int = Field(
+        default=500,
+        description="The maximum number of related resources an Event may have.",
+        validation_alias=AliasChoices(
+            AliasPath("maximum_related_resources"),
+            "prefect_server_events_maximum_related_resources",
+            "prefect_events_maximum_related_resources",
+        ),
+    )
+
+    maximum_size_bytes: int = Field(
+        default=1_500_000,
+        description="The maximum size of an Event when serialized to JSON",
+        validation_alias=AliasChoices(
+            AliasPath("maximum_size_bytes"),
+            "prefect_server_events_maximum_size_bytes",
+            "prefect_events_maximum_size_bytes",
+        ),
+    )
+
+    expired_bucket_buffer: timedelta = Field(
+        default=timedelta(seconds=60),
+        description="The amount of time to retain expired automation buckets",
+        validation_alias=AliasChoices(
+            AliasPath("expired_bucket_buffer"),
+            "prefect_server_events_expired_bucket_buffer",
+            "prefect_events_expired_bucket_buffer",
+        ),
+    )
+
+    proactive_granularity: timedelta = Field(
+        default=timedelta(seconds=5),
+        description="How frequently proactive automations are evaluated",
+        validation_alias=AliasChoices(
+            AliasPath("proactive_granularity"),
+            "prefect_server_events_proactive_granularity",
+            "prefect_events_proactive_granularity",
+        ),
+    )
+
+    retention_period: timedelta = Field(
+        default=timedelta(days=7),
+        description="The amount of time to retain events in the database.",
+        validation_alias=AliasChoices(
+            AliasPath("retention_period"),
+            "prefect_server_events_retention_period",
+            "prefect_events_retention_period",
+        ),
+    )
+
+    maximum_websocket_backfill: timedelta = Field(
+        default=timedelta(minutes=15),
+        description="The maximum range to look back for backfilling events for a websocket subscriber.",
+        validation_alias=AliasChoices(
+            AliasPath("maximum_websocket_backfill"),
+            "prefect_server_events_maximum_websocket_backfill",
+            "prefect_events_maximum_websocket_backfill",
+        ),
+    )
+
+    websocket_backfill_page_size: int = Field(
+        default=250,
+        gt=0,
+        description="The page size for the queries to backfill events for websocket subscribers.",
+        validation_alias=AliasChoices(
+            AliasPath("websocket_backfill_page_size"),
+            "prefect_server_events_websocket_backfill_page_size",
+            "prefect_events_websocket_backfill_page_size",
+        ),
+    )
+
+    messaging_broker: str = Field(
+        default="prefect.server.utilities.messaging.memory",
+        description="Which message broker implementation to use for the messaging system, should point to a module that exports a Publisher and Consumer class.",
+        validation_alias=AliasChoices(
+            AliasPath("messaging_broker"),
+            "prefect_server_events_messaging_broker",
+            "prefect_messaging_broker",
+        ),
+    )
+
+    messaging_cache: str = Field(
+        default="prefect.server.utilities.messaging.memory",
+        description="Which cache implementation to use for the events system.  Should point to a module that exports a Cache class.",
+        validation_alias=AliasChoices(
+            AliasPath("messaging_cache"),
+            "prefect_server_events_messaging_cache",
+            "prefect_messaging_cache",
+        ),
+    )

prefect/settings/models/server/flow_run_graph.py

@@ -0,0 +1,34 @@
+from pydantic import AliasChoices, AliasPath, Field
+from pydantic_settings import SettingsConfigDict
+
+from prefect.settings.base import PrefectBaseSettings
+
+
+class ServerFlowRunGraphSettings(PrefectBaseSettings):
+    """
+    Settings for controlling behavior of the flow run graph
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_SERVER_FLOW_RUN_GRAPH_", env_file=".env", extra="ignore"
+    )
+
+    max_nodes: int = Field(
+        default=10000,
+        description="The maximum size of a flow run graph on the v2 API",
+        validation_alias=AliasChoices(
+            AliasPath("max_nodes"),
+            "prefect_server_flow_run_graph_max_nodes",
+            "prefect_api_max_flow_run_graph_nodes",
+        ),
+    )
+
+    max_artifacts: int = Field(
+        default=10000,
+        description="The maximum number of artifacts to show on a flow run graph on the v2 API",
+        validation_alias=AliasChoices(
+            AliasPath("max_artifacts"),
+            "prefect_server_flow_run_graph_max_artifacts",
+            "prefect_api_max_flow_run_graph_artifacts",
+        ),
+    )

prefect/settings/models/server/root.py

@@ -0,0 +1,143 @@
+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
+from prefect.types import LogLevel
+
+from .api import ServerAPISettings
+from .database import ServerDatabaseSettings
+from .deployments import ServerDeploymentsSettings
+from .ephemeral import ServerEphemeralSettings
+from .events import ServerEventsSettings
+from .flow_run_graph import ServerFlowRunGraphSettings
+from .services import ServerServicesSettings
+from .tasks import ServerTasksSettings
+from .ui import ServerUISettings
+
+
+class ServerSettings(PrefectBaseSettings):
+    """
+    Settings for controlling server behavior
+    """
+
+    model_config = SettingsConfigDict(
+        env_prefix="PREFECT_SERVER_", env_file=".env", extra="ignore"
+    )
+
+    logging_level: LogLevel = Field(
+        default="WARNING",
+        description="The default logging level for the Prefect API server.",
+        validation_alias=AliasChoices(
+            AliasPath("logging_level"),
+            "prefect_server_logging_level",
+            "prefect_logging_server_level",
+        ),
+    )
+
+    analytics_enabled: bool = Field(
+        default=True,
+        description="""
+        When enabled, Prefect sends anonymous data (e.g. count of flow runs, package version)
+        on server startup to help us improve our product.
+        """,
+    )
+
+    metrics_enabled: bool = Field(
+        default=False,
+        description="Whether or not to enable Prometheus metrics in the API.",
+        validation_alias=AliasChoices(
+            AliasPath("metrics_enabled"),
+            "prefect_server_metrics_enabled",
+            "prefect_api_enable_metrics",
+        ),
+    )
+
+    log_retryable_errors: bool = Field(
+        default=False,
+        description="If `True`, log retryable errors in the API and it's services.",
+        validation_alias=AliasChoices(
+            AliasPath("log_retryable_errors"),
+            "prefect_server_log_retryable_errors",
+            "prefect_api_log_retryable_errors",
+        ),
+    )
+
+    register_blocks_on_start: bool = Field(
+        default=True,
+        description="If set, any block types that have been imported will be registered with the backend on application startup. If not set, block types must be manually registered.",
+        validation_alias=AliasChoices(
+            AliasPath("register_blocks_on_start"),
+            "prefect_server_register_blocks_on_start",
+            "prefect_api_blocks_register_on_start",
+        ),
+    )
+
+    memoize_block_auto_registration: bool = Field(
+        default=True,
+        description="Controls whether or not block auto-registration on start",
+        validation_alias=AliasChoices(
+            AliasPath("memoize_block_auto_registration"),
+            "prefect_server_memoize_block_auto_registration",
+            "prefect_memoize_block_auto_registration",
+        ),
+    )
+
+    memo_store_path: Optional[Path] = Field(
+        default=None,
+        description="The path to the memo store file.",
+        validation_alias=AliasChoices(
+            AliasPath("memo_store_path"),
+            "prefect_server_memo_store_path",
+            "prefect_memo_store_path",
+        ),
+    )
+
+    deployment_schedule_max_scheduled_runs: int = Field(
+        default=50,
+        description="The maximum number of scheduled runs to create for a deployment.",
+        validation_alias=AliasChoices(
+            AliasPath("deployment_schedule_max_scheduled_runs"),
+            "prefect_server_deployment_schedule_max_scheduled_runs",
+            "prefect_deployment_schedule_max_scheduled_runs",
+        ),
+    )
+
+    api: ServerAPISettings = Field(
+        default_factory=ServerAPISettings,
+        description="Settings for controlling API server behavior",
+    )
+    database: ServerDatabaseSettings = Field(
+        default_factory=ServerDatabaseSettings,
+        description="Settings for controlling server database behavior",
+    )
+    deployments: ServerDeploymentsSettings = Field(
+        default_factory=ServerDeploymentsSettings,
+        description="Settings for controlling server deployments behavior",
+    )
+    ephemeral: ServerEphemeralSettings = Field(
+        default_factory=ServerEphemeralSettings,
+        description="Settings for controlling ephemeral server behavior",
+    )
+    events: ServerEventsSettings = Field(
+        default_factory=ServerEventsSettings,
+        description="Settings for controlling server events behavior",
+    )
+    flow_run_graph: ServerFlowRunGraphSettings = Field(
+        default_factory=ServerFlowRunGraphSettings,
+        description="Settings for controlling flow run graph behavior",
+    )
+    services: ServerServicesSettings = Field(
+        default_factory=ServerServicesSettings,
+        description="Settings for controlling server services behavior",
+    )
+    tasks: ServerTasksSettings = Field(
+        default_factory=ServerTasksSettings,
+        description="Settings for controlling server tasks behavior",
+    )
+    ui: ServerUISettings = Field(
+        default_factory=ServerUISettings,
+        description="Settings for controlling server UI behavior",
+    )