prefect-client 3.2.2__py3-none-any.whl → 3.2.4__py3-none-any.whl

prefect/server/api/block_capabilities.py

@@ -0,0 +1,25 @@
+"""
+Routes for interacting with block capabilities.
+"""
+
+from typing import List
+
+from fastapi import Depends
+
+from prefect.server import models
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(
+    prefix="/block_capabilities", tags=["Block capabilities"]
+)
+
+
+@router.get("/")
+async def read_available_block_capabilities(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[str]:
+    async with db.session_context() as session:
+        return await models.block_schemas.read_available_block_capabilities(
+            session=session
+        )

prefect/server/api/block_documents.py

@@ -0,0 +1,164 @@
+"""
+Routes for interacting with block objects.
+"""
+
+from typing import List, Optional
+from uuid import UUID
+
+from fastapi import Body, Depends, HTTPException, Path, Query, status
+
+from prefect.server import models, schemas
+from prefect.server.api import dependencies
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(
+    prefix="/block_documents", tags=["Block documents"]
+)
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_block_document(
+    block_document: schemas.actions.BlockDocumentCreate,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockDocument:
+    """
+    Create a new block document.
+    """
+    async with db.session_context(begin_transaction=True) as session:
+        if block_document.name is not None:
+            exists = (
+                await models.block_documents.block_document_with_unique_values_exists(
+                    session=session,
+                    block_type_id=block_document.block_type_id,
+                    name=block_document.name,
+                )
+            )
+            if exists:
+                raise HTTPException(
+                    status.HTTP_409_CONFLICT,
+                    detail="Block already exists",
+                )
+
+        return await models.block_documents.create_block_document(
+            session=session, block_document=block_document
+        )
+
+
+@router.post("/filter")
+async def read_block_documents(
+    limit: int = dependencies.LimitBody(),
+    block_documents: Optional[schemas.filters.BlockDocumentFilter] = None,
+    block_types: Optional[schemas.filters.BlockTypeFilter] = None,
+    block_schemas: Optional[schemas.filters.BlockSchemaFilter] = None,
+    include_secrets: bool = Body(
+        False, description="Whether to include sensitive values in the block document."
+    ),
+    sort: Optional[schemas.sorting.BlockDocumentSort] = Body(
+        schemas.sorting.BlockDocumentSort.NAME_ASC
+    ),
+    offset: int = Body(0, ge=0),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[schemas.core.BlockDocument]:
+    """
+    Query for block documents.
+    """
+    async with db.session_context() as session:
+        result = await models.block_documents.read_block_documents(
+            session=session,
+            block_document_filter=block_documents,
+            block_type_filter=block_types,
+            block_schema_filter=block_schemas,
+            include_secrets=include_secrets,
+            sort=sort,
+            offset=offset,
+            limit=limit,
+        )
+
+    return result
+
+
+@router.post("/count")
+async def count_block_documents(
+    block_documents: Optional[schemas.filters.BlockDocumentFilter] = None,
+    block_types: Optional[schemas.filters.BlockTypeFilter] = None,
+    block_schemas: Optional[schemas.filters.BlockSchemaFilter] = None,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> int:
+    """
+    Count block documents.
+    """
+    async with db.session_context() as session:
+        result = await models.block_documents.count_block_documents(
+            session=session,
+            block_document_filter=block_documents,
+            block_type_filter=block_types,
+            block_schema_filter=block_schemas,
+        )
+
+    return result
+
+
+@router.get("/{id:uuid}")
+async def read_block_document_by_id(
+    block_document_id: UUID = Path(
+        ..., description="The block document id", alias="id"
+    ),
+    include_secrets: bool = Query(
+        False, description="Whether to include sensitive values in the block document."
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockDocument:
+    async with db.session_context() as session:
+        block_document = await models.block_documents.read_block_document_by_id(
+            session=session,
+            block_document_id=block_document_id,
+            include_secrets=include_secrets,
+        )
+    if not block_document:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, "Block document not found")
+    return block_document
+
+
+@router.delete("/{id:uuid}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_block_document(
+    block_document_id: UUID = Path(
+        ..., description="The block document id", alias="id"
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    async with db.session_context(begin_transaction=True) as session:
+        result = await models.block_documents.delete_block_document(
+            session=session, block_document_id=block_document_id
+        )
+    if not result:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND, detail="Block document not found"
+        )
+
+
+@router.patch("/{id:uuid}", status_code=status.HTTP_204_NO_CONTENT)
+async def update_block_document_data(
+    block_document: schemas.actions.BlockDocumentUpdate,
+    block_document_id: UUID = Path(
+        ..., description="The block document id", alias="id"
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    try:
+        async with db.session_context(begin_transaction=True) as session:
+            result = await models.block_documents.update_block_document(
+                session=session,
+                block_document_id=block_document_id,
+                block_document=block_document,
+            )
+    except ValueError as exc:
+        raise HTTPException(
+            status_code=status.HTTP_400_BAD_REQUEST,
+            detail=str(exc),
+        )
+
+    if not result:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND, detail="Block document not found"
+        )

prefect/server/api/block_schemas.py

@@ -0,0 +1,153 @@
+"""
+Routes for interacting with block schema objects.
+"""
+
+from typing import List, Optional
+from uuid import UUID
+
+from fastapi import (
+    Body,
+    Depends,
+    HTTPException,
+    Path,
+    Query,
+    Response,
+    status,
+)
+
+from prefect.server import models, schemas
+from prefect.server.api import dependencies
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.models.block_schemas import MissingBlockTypeException
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(prefix="/block_schemas", tags=["Block schemas"])
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_block_schema(
+    block_schema: schemas.actions.BlockSchemaCreate,
+    response: Response,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockSchema:
+    from prefect.blocks.core import Block
+
+    async with db.session_context(begin_transaction=True) as session:
+        block_type = await models.block_types.read_block_type(
+            session=session, block_type_id=block_schema.block_type_id
+        )
+        if block_type is None:
+            raise HTTPException(
+                status.HTTP_404_NOT_FOUND,
+                detail=f"Block type {block_schema.block_type_id} not found.",
+            )
+
+        block_schema_checksum = Block._calculate_schema_checksum(block_schema.fields)
+        existing_block_schema = (
+            await models.block_schemas.read_block_schema_by_checksum(
+                session=session,
+                checksum=block_schema_checksum,
+                version=block_schema.version,
+            )
+        )
+        if existing_block_schema:
+            response.status_code = status.HTTP_200_OK
+            return existing_block_schema
+        try:
+            model = await models.block_schemas.create_block_schema(
+                session=session,
+                block_schema=block_schema,
+            )
+        except MissingBlockTypeException as ex:
+            raise HTTPException(status.HTTP_409_CONFLICT, detail=str(ex))
+
+        return model
+
+
+@router.delete("/{id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_block_schema(
+    block_schema_id: UUID = Path(..., description="The block schema id", alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    api_version: str = Depends(dependencies.provide_request_api_version),
+) -> None:
+    """
+    Delete a block schema by id.
+    """
+    async with db.session_context(begin_transaction=True) as session:
+        block_schema = await models.block_schemas.read_block_schema(
+            session=session, block_schema_id=block_schema_id
+        )
+        if not block_schema:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Block schema not found"
+            )
+
+        if block_schema.block_type.is_protected:
+            raise HTTPException(
+                status.HTTP_403_FORBIDDEN,
+                detail="Block schemas for protected block types cannot be deleted.",
+            )
+
+        await models.block_schemas.delete_block_schema(
+            session=session, block_schema_id=block_schema_id
+        )
+
+
+@router.post("/filter")
+async def read_block_schemas(
+    block_schemas: Optional[schemas.filters.BlockSchemaFilter] = None,
+    limit: int = dependencies.LimitBody(),
+    offset: int = Body(0, ge=0),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[schemas.core.BlockSchema]:
+    """
+    Read all block schemas, optionally filtered by type
+    """
+    async with db.session_context() as session:
+        result = await models.block_schemas.read_block_schemas(
+            session=session,
+            block_schema_filter=block_schemas,
+            limit=limit,
+            offset=offset,
+        )
+    return result
+
+
+@router.get("/{id}")
+async def read_block_schema_by_id(
+    block_schema_id: UUID = Path(..., description="The block schema id", alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockSchema:
+    """
+    Get a block schema by id.
+    """
+    async with db.session_context() as session:
+        block_schema = await models.block_schemas.read_block_schema(
+            session=session, block_schema_id=block_schema_id
+        )
+    if not block_schema:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Block schema not found")
+    return block_schema
+
+
+@router.get("/checksum/{checksum}")
+async def read_block_schema_by_checksum(
+    block_schema_checksum: str = Path(
+        ..., description="The block schema checksum", alias="checksum"
+    ),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    version: Optional[str] = Query(
+        None,
+        description=(
+            "Version of block schema. If not provided the most recently created block"
+            " schema with the matching checksum will be returned."
+        ),
+    ),
+) -> schemas.core.BlockSchema:
+    async with db.session_context() as session:
+        block_schema = await models.block_schemas.read_block_schema_by_checksum(
+            session=session, checksum=block_schema_checksum, version=version
+        )
+    if not block_schema:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Block schema not found")
+    return block_schema

prefect/server/api/block_types.py

@@ -0,0 +1,211 @@
+from typing import List, Optional
+from uuid import UUID
+
+import sqlalchemy as sa
+from fastapi import Body, Depends, HTTPException, Path, Query, status
+
+from prefect.blocks.core import _should_update_block_type
+from prefect.server import models, schemas
+from prefect.server.api import dependencies
+from prefect.server.database import PrefectDBInterface, provide_database_interface
+from prefect.server.utilities.server import PrefectRouter
+
+router: PrefectRouter = PrefectRouter(prefix="/block_types", tags=["Block types"])
+
+
+@router.post("/", status_code=status.HTTP_201_CREATED)
+async def create_block_type(
+    block_type: schemas.actions.BlockTypeCreate,
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockType:
+    """
+    Create a new block type
+    """
+    # API-created blocks cannot start with the word "Prefect"
+    # as it is reserved for system use
+    if block_type.name.lower().startswith("prefect"):
+        raise HTTPException(
+            status.HTTP_403_FORBIDDEN,
+            detail="Block type names beginning with 'Prefect' are reserved.",
+        )
+    try:
+        async with db.session_context(begin_transaction=True) as session:
+            created_block_type = await models.block_types.create_block_type(
+                session, block_type=block_type
+            )
+    except sa.exc.IntegrityError:
+        raise HTTPException(
+            status.HTTP_409_CONFLICT,
+            detail=f'Block type with name "{block_type.name}" already exists',
+        )
+    return created_block_type
+
+
+@router.get("/{id}")
+async def read_block_type_by_id(
+    block_type_id: UUID = Path(..., description="The block type ID", alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockType:
+    """
+    Get a block type by ID.
+    """
+    async with db.session_context() as session:
+        block_type = await models.block_types.read_block_type(
+            session=session, block_type_id=block_type_id
+        )
+    if not block_type:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Block type not found")
+    return block_type
+
+
+@router.get("/slug/{slug}")
+async def read_block_type_by_slug(
+    block_type_slug: str = Path(..., description="The block type name", alias="slug"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> schemas.core.BlockType:
+    """
+    Get a block type by name.
+    """
+    async with db.session_context() as session:
+        block_type = await models.block_types.read_block_type_by_slug(
+            session=session, block_type_slug=block_type_slug
+        )
+    if not block_type:
+        raise HTTPException(status.HTTP_404_NOT_FOUND, detail="Block type not found")
+    return block_type
+
+
+@router.post("/filter")
+async def read_block_types(
+    block_types: Optional[schemas.filters.BlockTypeFilter] = None,
+    block_schemas: Optional[schemas.filters.BlockSchemaFilter] = None,
+    limit: int = dependencies.LimitBody(),
+    offset: int = Body(0, ge=0),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> List[schemas.core.BlockType]:
+    """
+    Gets all block types. Optionally limit return with limit and offset.
+    """
+    async with db.session_context() as session:
+        return await models.block_types.read_block_types(
+            session=session,
+            limit=limit,
+            offset=offset,
+            block_type_filter=block_types,
+            block_schema_filter=block_schemas,
+        )
+
+
+@router.patch("/{id}", status_code=status.HTTP_204_NO_CONTENT)
+async def update_block_type(
+    block_type: schemas.actions.BlockTypeUpdate,
+    block_type_id: UUID = Path(..., description="The block type ID", alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    """
+    Update a block type.
+    """
+    async with db.session_context(begin_transaction=True) as session:
+        db_block_type = await models.block_types.read_block_type(
+            session=session, block_type_id=block_type_id
+        )
+        if db_block_type is None:
+            raise HTTPException(
+                status.HTTP_404_NOT_FOUND, detail="Block type not found"
+            )
+
+        # Only update the block type if there is any meaningful changes.
+        # This avoids deadlocks when creating multiple blocks of the same type.
+        # This check happens client side, but we do it server side as well
+        # to accommodate older clients.
+        if _should_update_block_type(
+            block_type,
+            schemas.core.BlockType.model_validate(db_block_type, from_attributes=True),
+        ):
+            await models.block_types.update_block_type(
+                session=session, block_type=block_type, block_type_id=block_type_id
+            )
+
+
+@router.delete("/{id}", status_code=status.HTTP_204_NO_CONTENT)
+async def delete_block_type(
+    block_type_id: UUID = Path(..., description="The block type ID", alias="id"),
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    async with db.session_context(begin_transaction=True) as session:
+        db_block_type = await models.block_types.read_block_type(
+            session=session, block_type_id=block_type_id
+        )
+        if db_block_type is None:
+            raise HTTPException(
+                status_code=status.HTTP_404_NOT_FOUND, detail="Block type not found"
+            )
+        elif db_block_type.is_protected:
+            raise HTTPException(
+                status.HTTP_403_FORBIDDEN,
+                detail="protected block types cannot be deleted.",
+            )
+        await models.block_types.delete_block_type(
+            session=session, block_type_id=block_type_id
+        )
+
+
+@router.get("/slug/{slug}/block_documents", tags=router.tags + ["Block documents"])
+async def read_block_documents_for_block_type(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    block_type_slug: str = Path(..., description="The block type name", alias="slug"),
+    include_secrets: bool = Query(
+        False, description="Whether to include sensitive values in the block document."
+    ),
+) -> List[schemas.core.BlockDocument]:
+    async with db.session_context() as session:
+        block_type = await models.block_types.read_block_type_by_slug(
+            session=session, block_type_slug=block_type_slug
+        )
+        if not block_type:
+            raise HTTPException(
+                status.HTTP_404_NOT_FOUND, detail="Block type not found"
+            )
+        return await models.block_documents.read_block_documents(
+            session=session,
+            block_document_filter=schemas.filters.BlockDocumentFilter(
+                block_type_id=dict(any_=[block_type.id])
+            ),
+            include_secrets=include_secrets,
+        )
+
+
+@router.get(
+    "/slug/{slug}/block_documents/name/{block_document_name}",
+    tags=router.tags + ["Block documents"],
+)
+async def read_block_document_by_name_for_block_type(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+    block_type_slug: str = Path(..., description="The block type name", alias="slug"),
+    block_document_name: str = Path(..., description="The block type name"),
+    include_secrets: bool = Query(
+        False, description="Whether to include sensitive values in the block document."
+    ),
+) -> schemas.core.BlockDocument:
+    async with db.session_context() as session:
+        block_document = await models.block_documents.read_block_document_by_name(
+            session=session,
+            block_type_slug=block_type_slug,
+            name=block_document_name,
+            include_secrets=include_secrets,
+        )
+    if not block_document:
+        raise HTTPException(
+            status.HTTP_404_NOT_FOUND, detail="Block document not found"
+        )
+    return block_document
+
+
+@router.post("/install_system_block_types")
+async def install_system_block_types(
+    db: PrefectDBInterface = Depends(provide_database_interface),
+) -> None:
+    # Don't begin a transaction. _install_protected_system_blocks will manage
+    # the transactions.
+    async with db.session_context(begin_transaction=False) as session:
+        await models.block_registration._install_protected_system_blocks(session)