prefect 3.1.12.dev2__tar.gz → 3.1.12.dev4__tar.gz

{prefect-3.1.12.dev2/src/prefect.egg-info → prefect-3.1.12.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect
-Version: 3.1.12.dev2
+Version: 3.1.12.dev4
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.

{prefect-3.1.12.dev2 → prefect-3.1.12.dev4}/src/prefect/_version.py

@@ -8,11 +8,11 @@ import json
 
 version_json = '''
 {
- "date": "2025-01-03T17:01:03-0600",
+ "date": "2025-01-07T15:17:02-0600",
  "dirty": false,
  "error": null,
- "full-revisionid": "9461ae0b4a4afcdd425fe6577cd76a1165ee78f4",
- "version": "3.1.12.dev2"
+ "full-revisionid": "e9890a92f9483ad2c4a83be9daa226e0bcdfa2db",
+ "version": "3.1.12.dev4"
 }
 '''  # END VERSION_JSON
 

{prefect-3.1.12.dev2 → prefect-3.1.12.dev4}/src/prefect/cli/deploy.py

@@ -9,7 +9,7 @@ from copy import deepcopy
 from datetime import timedelta
 from getpass import GetPassWarning
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 from uuid import UUID
 
 import pydantic
@@ -398,7 +398,7 @@ async def deploy(
         )
     )
 
-    options = {
+    options: dict[str, Any] = {
         "entrypoint": entrypoint,
         "description": description,
         "version": version,
@@ -417,11 +417,12 @@ async def deploy(
         "params": params,
         "sla": sla,
     }
+
     try:
         deploy_configs, actions = _load_deploy_configs_and_actions(
             prefect_file=prefect_file,
         )
-        parsed_names = []
+        parsed_names: list[str] = []
         for name in names or []:
             if "*" in name:
                 parsed_names.extend(_parse_name_from_pattern(deploy_configs, name))
@@ -450,14 +451,18 @@ async def deploy(
                 prefect_file=prefect_file,
             )
         else:
+            deploy_config = deploy_configs[0] if deploy_configs else {}
             # Accommodate passing in -n flow-name/deployment-name as well as -n deployment-name
             options["names"] = [
                 name.split("/", 1)[-1] if "/" in name else name for name in parsed_names
             ]
-            options["enforce_parameter_schema"] = enforce_parameter_schema
+
+            # Only set enforce_parameter_schema in options if CLI flag was explicitly passed
+            if not enforce_parameter_schema:
+                options["enforce_parameter_schema"] = False
 
             await _run_single_deploy(
-                deploy_config=deploy_configs[0] if deploy_configs else {},
+                deploy_config=deploy_config,
                 actions=actions,
                 options=options,
                 prefect_file=prefect_file,
@@ -670,7 +675,7 @@ async def _run_single_deploy(
     )
 
     ## RUN BUILD AND PUSH STEPS
-    step_outputs = {}
+    step_outputs: dict[str, Any] = {}
     if build_steps:
         app.console.print("Running deployment build steps...")
         step_outputs.update(
@@ -1232,12 +1237,12 @@ async def _generate_default_pull_action(
 
 def _load_deploy_configs_and_actions(
     prefect_file: Path,
-) -> Tuple[List[Dict], Dict]:
+) -> tuple[list[dict[str, Any]], dict[str, Any]]:
     """
     Load deploy configs and actions from a deployment configuration YAML file.
 
     Returns:
-        Tuple[List[Dict], Dict]: a tuple of deployment configurations and actions
+        tuple[list[dict[str, Any]], dict[str, Any]]: a tuple of deployment configurations and actions
     """
     try:
         with prefect_file.open("r") as f:
@@ -1247,15 +1252,15 @@ def _load_deploy_configs_and_actions(
             f"Unable to read the specified config file. Reason: {exc}. Skipping.",
             style="yellow",
         )
-        prefect_yaml_contents = {}
+        prefect_yaml_contents: dict[str, Any] = {}
     if not isinstance(prefect_yaml_contents, dict):
         app.console.print(
             "Unable to parse the specified config file. Skipping.",
             style="yellow",
         )
-        prefect_yaml_contents = {}
+        prefect_yaml_contents: dict[str, Any] = {}
 
-    actions = {
+    actions: dict[str, Any] = {
         "build": prefect_yaml_contents.get("build", []),
         "push": prefect_yaml_contents.get("push", []),
         "pull": prefect_yaml_contents.get("pull", []),
@@ -1266,7 +1271,9 @@ def _load_deploy_configs_and_actions(
     return deploy_configs, actions
 
 
-def _handle_pick_deploy_without_name(deploy_configs):
+def _handle_pick_deploy_without_name(
+    deploy_configs: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
     # Prompt the user to select one or more deployment configurations
     selectable_deploy_configs = [
         deploy_config for deploy_config in deploy_configs if deploy_config.get("name")
@@ -1331,7 +1338,9 @@ def _filter_matching_deploy_config(name, deploy_configs):
     return matching_deployments
 
 
-def _parse_name_from_pattern(deploy_configs, name_pattern):
+def _parse_name_from_pattern(
+    deploy_configs: list[dict[str, Any]], name_pattern: str
+) -> list[str]:
     """
     Parse the deployment names from a user-provided pattern such as "flow-name/*" or "my-deployment-*"
 
@@ -1353,7 +1362,7 @@ def _parse_name_from_pattern(deploy_configs, name_pattern):
     Returns:
         List[str]: a list of deployment names that match the given pattern
     """
-    parsed_names = []
+    parsed_names: list[str] = []
 
     name_pattern = re.escape(name_pattern).replace(r"\*", ".*")
 
@@ -1390,11 +1399,11 @@ def _parse_name_from_pattern(deploy_configs, name_pattern):
 
 
 def _handle_pick_deploy_with_name(
-    deploy_configs,
-    names,
-):
-    matched_deploy_configs = []
-    deployment_names = []
+    deploy_configs: list[dict[str, Any]],
+    names: list[str],
+) -> list[dict[str, Any]]:
+    matched_deploy_configs: list[dict[str, Any]] = []
+    deployment_names: list[str] = []
     for name in names:
         matching_deployments = _filter_matching_deploy_config(name, deploy_configs)
 
@@ -1430,10 +1439,10 @@ def _handle_pick_deploy_with_name(
 
 
 def _pick_deploy_configs(
-    deploy_configs,
-    names,
-    deploy_all,
-):
+    deploy_configs: list[dict[str, Any]],
+    names: list[str],
+    deploy_all: bool,
+) -> list[dict[str, Any]]:
     """
     Return a list of deploy configs to deploy based on the given
     deploy configs, names, and deploy_all flag.
@@ -1480,7 +1489,7 @@ def _pick_deploy_configs(
         return []
 
 
-def _extract_variable(variable: str) -> Dict[str, Any]:
+def _extract_variable(variable: str) -> dict[str, Any]:
     """
     Extracts a variable from a string. Variables can be in the format
     key=value or a JSON object.
@@ -1505,7 +1514,9 @@ def _extract_variable(variable: str) -> Dict[str, Any]:
         ) from e
 
 
-def _apply_cli_options_to_deploy_config(deploy_config, cli_options):
+def _apply_cli_options_to_deploy_config(
+    deploy_config: dict[str, Any], cli_options: dict[str, Any]
+) -> dict[str, Any]:
     """
     Applies CLI options to a deploy config. CLI options take
     precedence over values in the deploy config.
@@ -1528,7 +1539,7 @@ def _apply_cli_options_to_deploy_config(deploy_config, cli_options):
     if len(cli_options.get("names", [])) == 1:
         deploy_config["name"] = cli_options["names"][0]
 
-    variable_overrides = {}
+    variable_overrides: dict[str, Any] = {}
     for cli_option, cli_value in cli_options.items():
         if (
             cli_option
@@ -1570,7 +1581,7 @@ def _apply_cli_options_to_deploy_config(deploy_config, cli_options):
                 deploy_config["schedules"].append({cli_option: value})
 
         elif cli_option in ["param", "params"] and cli_value:
-            parameters = dict()
+            parameters: dict[str, Any] = {}
             if cli_option == "param":
                 for p in cli_value or []:
                     k, unparsed_value = p.split("=", 1)

{prefect-3.1.12.dev2 → prefect-3.1.12.dev4}/src/prefect/client/orchestration/__init__.py

@@ -81,11 +81,6 @@ import prefect.states
 from prefect.client.constants import SERVER_API_VERSION
 from prefect.client.schemas import FlowRun, OrchestrationResult, TaskRun
 from prefect.client.schemas.actions import (
-    BlockDocumentCreate,
-    BlockDocumentUpdate,
-    BlockSchemaCreate,
-    BlockTypeCreate,
-    BlockTypeUpdate,
     FlowRunNotificationPolicyCreate,
     FlowRunNotificationPolicyUpdate,
     TaskRunCreate,
@@ -107,9 +102,6 @@ from prefect.client.schemas.filters import (
     WorkQueueFilterName,
 )
 from prefect.client.schemas.objects import (
-    BlockDocument,
-    BlockSchema,
-    BlockType,
     Constant,
     FlowRunNotificationPolicy,
     Parameter,
@@ -750,383 +742,6 @@ class PrefectClient(
             else:
                 raise
 
-    async def create_block_type(self, block_type: BlockTypeCreate) -> BlockType:
-        """
-        Create a block type in the Prefect API.
-        """
-        try:
-            response = await self._client.post(
-                "/block_types/",
-                json=block_type.model_dump(
-                    mode="json", exclude_unset=True, exclude={"id"}
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_409_CONFLICT:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
-            else:
-                raise
-        return BlockType.model_validate(response.json())
-
-    async def create_block_schema(self, block_schema: BlockSchemaCreate) -> BlockSchema:
-        """
-        Create a block schema in the Prefect API.
-        """
-        try:
-            response = await self._client.post(
-                "/block_schemas/",
-                json=block_schema.model_dump(
-                    mode="json",
-                    exclude_unset=True,
-                    exclude={"id", "block_type", "checksum"},
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_409_CONFLICT:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
-            else:
-                raise
-        return BlockSchema.model_validate(response.json())
-
-    async def create_block_document(
-        self,
-        block_document: Union[BlockDocument, BlockDocumentCreate],
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Create a block document in the Prefect API. This data is used to configure a
-        corresponding Block.
-
-        Args:
-            include_secrets (bool): whether to include secret values
-                on the stored Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. Note Blocks may not work as expected if
-                this is set to `False`.
-        """
-        block_document_data = block_document.model_dump(
-            mode="json",
-            exclude_unset=True,
-            exclude={"id", "block_schema", "block_type"},
-            context={"include_secrets": include_secrets},
-            serialize_as_any=True,
-        )
-        try:
-            response = await self._client.post(
-                "/block_documents/",
-                json=block_document_data,
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_409_CONFLICT:
-                raise prefect.exceptions.ObjectAlreadyExists(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())
-
-    async def update_block_document(
-        self,
-        block_document_id: UUID,
-        block_document: BlockDocumentUpdate,
-    ) -> None:
-        """
-        Update a block document in the Prefect API.
-        """
-        try:
-            await self._client.patch(
-                f"/block_documents/{block_document_id}",
-                json=block_document.model_dump(
-                    mode="json",
-                    exclude_unset=True,
-                    include={"data", "merge_existing_data", "block_schema_id"},
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def delete_block_document(self, block_document_id: UUID) -> None:
-        """
-        Delete a block document.
-        """
-        try:
-            await self._client.delete(f"/block_documents/{block_document_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def read_block_type_by_slug(self, slug: str) -> BlockType:
-        """
-        Read a block type by its slug.
-        """
-        try:
-            response = await self._client.get(f"/block_types/slug/{slug}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockType.model_validate(response.json())
-
-    async def read_block_schema_by_checksum(
-        self, checksum: str, version: Optional[str] = None
-    ) -> BlockSchema:
-        """
-        Look up a block schema checksum
-        """
-        try:
-            url = f"/block_schemas/checksum/{checksum}"
-            if version is not None:
-                url = f"{url}?version={version}"
-            response = await self._client.get(url)
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockSchema.model_validate(response.json())
-
-    async def update_block_type(
-        self, block_type_id: UUID, block_type: BlockTypeUpdate
-    ) -> None:
-        """
-        Update a block document in the Prefect API.
-        """
-        try:
-            await self._client.patch(
-                f"/block_types/{block_type_id}",
-                json=block_type.model_dump(
-                    mode="json",
-                    exclude_unset=True,
-                    include=BlockTypeUpdate.updatable_fields(),
-                ),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-
-    async def delete_block_type(self, block_type_id: UUID) -> None:
-        """
-        Delete a block type.
-        """
-        try:
-            await self._client.delete(f"/block_types/{block_type_id}")
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == 404:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            elif (
-                e.response.status_code == status.HTTP_403_FORBIDDEN
-                and e.response.json()["detail"]
-                == "protected block types cannot be deleted."
-            ):
-                raise prefect.exceptions.ProtectedBlockError(
-                    "Protected block types cannot be deleted."
-                ) from e
-            else:
-                raise
-
-    async def read_block_types(self) -> list[BlockType]:
-        """
-        Read all block types
-        Raises:
-            httpx.RequestError: if the block types were not found
-
-        Returns:
-            List of BlockTypes.
-        """
-        response = await self._client.post("/block_types/filter", json={})
-        return pydantic.TypeAdapter(list[BlockType]).validate_python(response.json())
-
-    async def read_block_schemas(self) -> list[BlockSchema]:
-        """
-        Read all block schemas
-        Raises:
-            httpx.RequestError: if a valid block schema was not found
-
-        Returns:
-            A BlockSchema.
-        """
-        response = await self._client.post("/block_schemas/filter", json={})
-        return pydantic.TypeAdapter(list[BlockSchema]).validate_python(response.json())
-
-    async def get_most_recent_block_schema_for_block_type(
-        self,
-        block_type_id: UUID,
-    ) -> Optional[BlockSchema]:
-        """
-        Fetches the most recent block schema for a specified block type ID.
-
-        Args:
-            block_type_id: The ID of the block type.
-
-        Raises:
-            httpx.RequestError: If the request fails for any reason.
-
-        Returns:
-            The most recent block schema or None.
-        """
-        try:
-            response = await self._client.post(
-                "/block_schemas/filter",
-                json={
-                    "block_schemas": {"block_type_id": {"any_": [str(block_type_id)]}},
-                    "limit": 1,
-                },
-            )
-        except httpx.HTTPStatusError:
-            raise
-        return (
-            BlockSchema.model_validate(response.json()[0]) if response.json() else None
-        )
-
-    async def read_block_document(
-        self,
-        block_document_id: UUID,
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Read the block document with the specified ID.
-
-        Args:
-            block_document_id: the block document id
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Raises:
-            httpx.RequestError: if the block document was not found for any reason
-
-        Returns:
-            A block document or None.
-        """
-        assert (
-            block_document_id is not None
-        ), "Unexpected ID on block document. Was it persisted?"
-        try:
-            response = await self._client.get(
-                f"/block_documents/{block_document_id}",
-                params=dict(include_secrets=include_secrets),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())
-
-    async def read_block_document_by_name(
-        self,
-        name: str,
-        block_type_slug: str,
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Read the block document with the specified name that corresponds to a
-        specific block type name.
-
-        Args:
-            name: The block document name.
-            block_type_slug: The block type slug.
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Raises:
-            httpx.RequestError: if the block document was not found for any reason
-
-        Returns:
-            A block document or None.
-        """
-        try:
-            response = await self._client.get(
-                f"/block_types/slug/{block_type_slug}/block_documents/name/{name}",
-                params=dict(include_secrets=include_secrets),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())
-
-    async def read_block_documents(
-        self,
-        block_schema_type: Optional[str] = None,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-        include_secrets: bool = True,
-    ) -> list[BlockDocument]:
-        """
-        Read block documents
-
-        Args:
-            block_schema_type: an optional block schema type
-            offset: an offset
-            limit: the number of blocks to return
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Returns:
-            A list of block documents
-        """
-        response = await self._client.post(
-            "/block_documents/filter",
-            json=dict(
-                block_schema_type=block_schema_type,
-                offset=offset,
-                limit=limit,
-                include_secrets=include_secrets,
-            ),
-        )
-        return pydantic.TypeAdapter(list[BlockDocument]).validate_python(
-            response.json()
-        )
-
-    async def read_block_documents_by_type(
-        self,
-        block_type_slug: str,
-        offset: Optional[int] = None,
-        limit: Optional[int] = None,
-        include_secrets: bool = True,
-    ) -> list[BlockDocument]:
-        """Retrieve block documents by block type slug.
-
-        Args:
-            block_type_slug: The block type slug.
-            offset: an offset
-            limit: the number of blocks to return
-            include_secrets: whether to include secret values
-
-        Returns:
-            A list of block documents
-        """
-        response = await self._client.get(
-            f"/block_types/slug/{block_type_slug}/block_documents",
-            params=dict(
-                offset=offset,
-                limit=limit,
-                include_secrets=include_secrets,
-            ),
-        )
-
-        return pydantic.TypeAdapter(list[BlockDocument]).validate_python(
-            response.json()
-        )
-
     async def set_task_run_name(self, task_run_id: UUID, name: str) -> httpx.Response:
         task_run_data = TaskRunUpdate(name=name)
         return await self._client.patch(
@@ -2340,41 +1955,3 @@ class SyncPrefectClient(
         return pydantic.TypeAdapter(list[prefect.states.State]).validate_python(
             response.json()
         )
-
-    def read_block_document_by_name(
-        self,
-        name: str,
-        block_type_slug: str,
-        include_secrets: bool = True,
-    ) -> BlockDocument:
-        """
-        Read the block document with the specified name that corresponds to a
-        specific block type name.
-
-        Args:
-            name: The block document name.
-            block_type_slug: The block type slug.
-            include_secrets (bool): whether to include secret values
-                on the Block, corresponding to Pydantic's `SecretStr` and
-                `SecretBytes` fields. These fields are automatically obfuscated
-                by Pydantic, but users can additionally choose not to receive
-                their values from the API. Note that any business logic on the
-                Block may not work if this is `False`.
-
-        Raises:
-            httpx.RequestError: if the block document was not found for any reason
-
-        Returns:
-            A block document or None.
-        """
-        try:
-            response = self._client.get(
-                f"/block_types/slug/{block_type_slug}/block_documents/name/{name}",
-                params=dict(include_secrets=include_secrets),
-            )
-        except httpx.HTTPStatusError as e:
-            if e.response.status_code == status.HTTP_404_NOT_FOUND:
-                raise prefect.exceptions.ObjectNotFound(http_exc=e) from e
-            else:
-                raise
-        return BlockDocument.model_validate(response.json())

{prefect-3.1.12.dev2 → prefect-3.1.12.dev4}/src/prefect/client/orchestration/_blocks_schemas/client.py

@@ -49,7 +49,7 @@ class BlocksSchemaClient(BaseClient):
                 "GET",
                 "/block_schemas/checksum/{checksum}",
                 path_params={"checksum": checksum},
-                params={"version": version},
+                **({"params": {"version": version}} if version else {}),
             )
         except HTTPStatusError as e:
             if e.response.status_code == 404:
@@ -143,7 +143,7 @@ class BlocksSchemaAsyncClient(BaseAsyncClient):
                 "GET",
                 "/block_schemas/checksum/{checksum}",
                 path_params={"checksum": checksum},
-                params={"version": version},
+                **({"params": {"version": version}} if version else {}),
             )
         except HTTPStatusError as e:
             if e.response.status_code == 404: