zenml-nightly 0.75.0.dev20250312__py3-none-any.whl → 0.75.0.dev20250314__py3-none-any.whl

zenml/zen_server/routers/projects_endpoints.py

@@ -0,0 +1,283 @@
+#  Copyright (c) ZenML GmbH 2022. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Endpoint definitions for projects."""
+
+from typing import Union
+from uuid import UUID
+
+from fastapi import APIRouter, Depends, Security
+
+from zenml.constants import (
+    API,
+    PROJECTS,
+    STATISTICS,
+    VERSION_1,
+    WORKSPACES,
+)
+from zenml.models import (
+    Page,
+    PipelineFilter,
+    PipelineRunFilter,
+    ProjectFilter,
+    ProjectRequest,
+    ProjectResponse,
+    ProjectStatistics,
+    ProjectUpdate,
+)
+from zenml.zen_server.auth import AuthContext, authorize
+from zenml.zen_server.exceptions import error_response
+from zenml.zen_server.rbac.endpoint_utils import (
+    verify_permissions_and_create_entity,
+    verify_permissions_and_delete_entity,
+    verify_permissions_and_get_entity,
+    verify_permissions_and_list_entities,
+    verify_permissions_and_update_entity,
+)
+from zenml.zen_server.rbac.models import ResourceType
+from zenml.zen_server.rbac.utils import (
+    get_allowed_resource_ids,
+)
+from zenml.zen_server.utils import (
+    handle_exceptions,
+    make_dependable,
+    zen_store,
+)
+
+workspace_router = APIRouter(
+    prefix=API + VERSION_1 + WORKSPACES,
+    tags=["workspaces"],
+    responses={401: error_response},
+)
+
+router = APIRouter(
+    prefix=API + VERSION_1 + PROJECTS,
+    tags=["projects"],
+    responses={401: error_response},
+)
+
+
+# TODO: kept for backwards compatibility only; to be removed after the migration
+@workspace_router.get(
+    "",
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+)
+@router.get(
+    "",
+    responses={401: error_response, 404: error_response, 422: error_response},
+)
+@handle_exceptions
+def list_projects(
+    project_filter_model: ProjectFilter = Depends(
+        make_dependable(ProjectFilter)
+    ),
+    hydrate: bool = False,
+    _: AuthContext = Security(authorize),
+) -> Page[ProjectResponse]:
+    """Lists all projects in the organization.
+
+    Args:
+        project_filter_model: Filter model used for pagination, sorting,
+            filtering,
+        hydrate: Flag deciding whether to hydrate the output model(s)
+            by including metadata fields in the response.
+
+    Returns:
+        A list of projects.
+    """
+    return verify_permissions_and_list_entities(
+        filter_model=project_filter_model,
+        resource_type=ResourceType.PROJECT,
+        list_method=zen_store().list_projects,
+        hydrate=hydrate,
+    )
+
+
+# TODO: kept for backwards compatibility only; to be removed after the migration
+@workspace_router.post(
+    "",
+    responses={401: error_response, 409: error_response, 422: error_response},
+    deprecated=True,
+)
+@router.post(
+    "",
+    responses={401: error_response, 409: error_response, 422: error_response},
+)
+@handle_exceptions
+def create_project(
+    project_request: ProjectRequest,
+    _: AuthContext = Security(authorize),
+) -> ProjectResponse:
+    """Creates a project based on the requestBody.
+
+    # noqa: DAR401
+
+    Args:
+        project_request: Project to create.
+
+    Returns:
+        The created project.
+    """
+    return verify_permissions_and_create_entity(
+        request_model=project_request,
+        create_method=zen_store().create_project,
+    )
+
+
+# TODO: kept for backwards compatibility only; to be removed after the migration
+@workspace_router.get(
+    "/{project_name_or_id}",
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+)
+@router.get(
+    "/{project_name_or_id}",
+    responses={401: error_response, 404: error_response, 422: error_response},
+)
+@handle_exceptions
+def get_project(
+    project_name_or_id: Union[str, UUID],
+    hydrate: bool = True,
+    _: AuthContext = Security(authorize),
+) -> ProjectResponse:
+    """Get a project for given name.
+
+    # noqa: DAR401
+
+    Args:
+        project_name_or_id: Name or ID of the project.
+        hydrate: Flag deciding whether to hydrate the output model(s)
+            by including metadata fields in the response.
+
+    Returns:
+        The requested project.
+    """
+    return verify_permissions_and_get_entity(
+        id=project_name_or_id,
+        get_method=zen_store().get_project,
+        hydrate=hydrate,
+    )
+
+
+# TODO: kept for backwards compatibility only; to be removed after the migration
+@workspace_router.put(
+    "/{project_name_or_id}",
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+)
+@router.put(
+    "/{project_name_or_id}",
+    responses={401: error_response, 404: error_response, 422: error_response},
+)
+@handle_exceptions
+def update_project(
+    project_name_or_id: UUID,
+    project_update: ProjectUpdate,
+    _: AuthContext = Security(authorize),
+) -> ProjectResponse:
+    """Get a project for given name.
+
+    # noqa: DAR401
+
+    Args:
+        project_name_or_id: Name or ID of the project to update.
+        project_update: the project to use to update
+
+    Returns:
+        The updated project.
+    """
+    return verify_permissions_and_update_entity(
+        id=project_name_or_id,
+        update_model=project_update,
+        get_method=zen_store().get_project,
+        update_method=zen_store().update_project,
+    )
+
+
+# TODO: kept for backwards compatibility only; to be removed after the migration
+@workspace_router.delete(
+    "/{project_name_or_id}",
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+)
+@router.delete(
+    "/{project_name_or_id}",
+    responses={401: error_response, 404: error_response, 422: error_response},
+)
+@handle_exceptions
+def delete_project(
+    project_name_or_id: Union[str, UUID],
+    _: AuthContext = Security(authorize),
+) -> None:
+    """Deletes a project.
+
+    Args:
+        project_name_or_id: Name or ID of the project.
+    """
+    verify_permissions_and_delete_entity(
+        id=project_name_or_id,
+        get_method=zen_store().get_project,
+        delete_method=zen_store().delete_project,
+    )
+
+
+# TODO: kept for backwards compatibility only; to be removed after the migration
+@workspace_router.get(
+    "/{project_name_or_id}" + STATISTICS,
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+)
+@router.get(
+    "/{project_name_or_id}" + STATISTICS,
+    responses={401: error_response, 404: error_response, 422: error_response},
+)
+@handle_exceptions
+def get_project_statistics(
+    project_name_or_id: Union[str, UUID],
+    auth_context: AuthContext = Security(authorize),
+) -> ProjectStatistics:
+    """Gets statistics of a project.
+
+    # noqa: DAR401
+
+    Args:
+        project_name_or_id: Name or ID of the project to get statistics for.
+        auth_context: Authentication context.
+
+    Returns:
+        Project statistics.
+    """
+    project = verify_permissions_and_get_entity(
+        id=project_name_or_id,
+        get_method=zen_store().get_project,
+    )
+
+    user_id = auth_context.user.id
+
+    run_filter = PipelineRunFilter(project=project.id)
+    run_filter.configure_rbac(
+        authenticated_user_id=user_id,
+        id=get_allowed_resource_ids(resource_type=ResourceType.PIPELINE_RUN),
+    )
+
+    pipeline_filter = PipelineFilter(project=project.id)
+    pipeline_filter.configure_rbac(
+        authenticated_user_id=user_id,
+        id=get_allowed_resource_ids(resource_type=ResourceType.PIPELINE),
+    )
+
+    return ProjectStatistics(
+        pipelines=zen_store().count_pipelines(filter_model=pipeline_filter),
+        runs=zen_store().count_runs(filter_model=run_filter),
+    )

zenml/zen_server/routers/run_metadata_endpoints.py

@@ -0,0 +1,97 @@
+#  Copyright (c) ZenML GmbH 2025. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       https://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
+"""Endpoint definitions for run metadata."""
+
+from typing import Any, List, Optional, Union
+from uuid import UUID
+
+from fastapi import APIRouter, Security
+
+from zenml.constants import API, RUN_METADATA, VERSION_1
+from zenml.enums import MetadataResourceTypes
+from zenml.models import RunMetadataRequest
+from zenml.zen_server.auth import AuthContext, authorize
+from zenml.zen_server.exceptions import error_response
+from zenml.zen_server.rbac.models import Action
+from zenml.zen_server.rbac.utils import (
+    batch_verify_permissions_for_models,
+    verify_permission_for_model,
+)
+from zenml.zen_server.routers.projects_endpoints import workspace_router
+from zenml.zen_server.utils import handle_exceptions, zen_store
+
+router = APIRouter(
+    prefix=API + VERSION_1 + RUN_METADATA,
+    tags=["run_metadata"],
+    responses={401: error_response, 403: error_response},
+)
+
+
+@router.post(
+    "",
+    responses={401: error_response, 409: error_response, 422: error_response},
+)
+# TODO: the workspace scoped endpoint is only kept for dashboard compatibility
+# and can be removed after the migration
+@workspace_router.post(
+    "/{project_name_or_id}" + RUN_METADATA,
+    responses={401: error_response, 409: error_response, 422: error_response},
+    deprecated=True,
+    tags=["run_metadata"],
+)
+@handle_exceptions
+def create_run_metadata(
+    run_metadata: RunMetadataRequest,
+    project_name_or_id: Optional[Union[str, UUID]] = None,
+    auth_context: AuthContext = Security(authorize),
+) -> None:
+    """Creates run metadata.
+
+    Args:
+        run_metadata: The run metadata to create.
+        project_name_or_id: Optional name or ID of the project.
+        auth_context: Authentication context.
+
+    Raises:
+        RuntimeError: If the resource type is not supported.
+    """
+    if project_name_or_id:
+        project = zen_store().get_project(project_name_or_id)
+        run_metadata.project = project.id
+
+    run_metadata.user = auth_context.user.id
+
+    verify_models: List[Any] = []
+    for resource in run_metadata.resources:
+        if resource.type == MetadataResourceTypes.PIPELINE_RUN:
+            verify_models.append(zen_store().get_run(resource.id))
+        elif resource.type == MetadataResourceTypes.STEP_RUN:
+            verify_models.append(zen_store().get_run_step(resource.id))
+        elif resource.type == MetadataResourceTypes.ARTIFACT_VERSION:
+            verify_models.append(zen_store().get_artifact_version(resource.id))
+        elif resource.type == MetadataResourceTypes.MODEL_VERSION:
+            verify_models.append(zen_store().get_model_version(resource.id))
+        elif resource.type == MetadataResourceTypes.SCHEDULE:
+            verify_models.append(zen_store().get_schedule(resource.id))
+        else:
+            raise RuntimeError(f"Unknown resource type: {resource.type}")
+
+    batch_verify_permissions_for_models(
+        models=verify_models,
+        action=Action.UPDATE,
+    )
+
+    verify_permission_for_model(model=run_metadata, action=Action.CREATE)
+
+    zen_store().create_run_metadata(run_metadata)

zenml/zen_server/routers/run_templates_endpoints.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Endpoint definitions for run templates."""
 
-from typing import Optional
+from typing import Optional, Union
 from uuid import UUID
 
 from fastapi import APIRouter, BackgroundTasks, Depends, Security
@@ -26,12 +26,14 @@ from zenml.models import (
     Page,
     PipelineRunResponse,
     RunTemplateFilter,
+    RunTemplateRequest,
     RunTemplateResponse,
     RunTemplateUpdate,
 )
 from zenml.zen_server.auth import AuthContext, authorize
 from zenml.zen_server.exceptions import error_response
 from zenml.zen_server.rbac.endpoint_utils import (
+    verify_permissions_and_create_entity,
     verify_permissions_and_delete_entity,
     verify_permissions_and_get_entity,
     verify_permissions_and_list_entities,
@@ -39,6 +41,7 @@ from zenml.zen_server.rbac.endpoint_utils import (
 )
 from zenml.zen_server.rbac.models import Action, ResourceType
 from zenml.zen_server.rbac.utils import verify_permission
+from zenml.zen_server.routers.projects_endpoints import workspace_router
 from zenml.zen_server.utils import (
     handle_exceptions,
     make_dependable,
@@ -53,15 +56,61 @@ router = APIRouter(
 )
 
 
+@router.post(
+    "",
+    responses={401: error_response, 409: error_response, 422: error_response},
+)
+# TODO: the workspace scoped endpoint is only kept for dashboard compatibility
+# and can be removed after the migration
+@workspace_router.post(
+    "/{project_name_or_id}" + RUN_TEMPLATES,
+    responses={401: error_response, 409: error_response, 422: error_response},
+    deprecated=True,
+    tags=["run_templates"],
+)
+@handle_exceptions
+def create_run_template(
+    run_template: RunTemplateRequest,
+    project_name_or_id: Optional[Union[str, UUID]] = None,
+    _: AuthContext = Security(authorize),
+) -> RunTemplateResponse:
+    """Create a run template.
+
+    Args:
+        run_template: Run template to create.
+        project_name_or_id: Optional name or ID of the project.
+
+    Returns:
+        The created run template.
+    """
+    if project_name_or_id:
+        project = zen_store().get_project(project_name_or_id)
+        run_template.project = project.id
+
+    return verify_permissions_and_create_entity(
+        request_model=run_template,
+        create_method=zen_store().create_run_template,
+    )
+
+
 @router.get(
     "",
     responses={401: error_response, 404: error_response, 422: error_response},
 )
+# TODO: the workspace scoped endpoint is only kept for dashboard compatibility
+# and can be removed after the migration
+@workspace_router.get(
+    "/{project_name_or_id}" + RUN_TEMPLATES,
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+    tags=["run_templates"],
+)
 @handle_exceptions
 def list_run_templates(
     filter_model: RunTemplateFilter = Depends(
         make_dependable(RunTemplateFilter)
     ),
+    project_name_or_id: Optional[Union[str, UUID]] = None,
     hydrate: bool = False,
     _: AuthContext = Security(authorize),
 ) -> Page[RunTemplateResponse]:
@@ -70,12 +119,16 @@ def list_run_templates(
     Args:
         filter_model: Filter model used for pagination, sorting,
             filtering.
+        project_name_or_id: Optional name or ID of the project.
         hydrate: Flag deciding whether to hydrate the output model(s)
             by including metadata fields in the response.
 
     Returns:
         Page of run templates.
     """
+    if project_name_or_id:
+        filter_model.project = project_name_or_id
+
     return verify_permissions_and_list_entities(
         filter_model=filter_model,
         resource_type=ResourceType.RUN_TEMPLATE,
@@ -189,19 +242,27 @@ if server_config().workload_manager_enabled:
         """
         from zenml.zen_server.template_execution.utils import run_template
 
-        with track_handler(event=AnalyticsEvent.EXECUTED_RUN_TEMPLATE):
+        with track_handler(
+            event=AnalyticsEvent.EXECUTED_RUN_TEMPLATE,
+        ) as analytics_handler:
             template = verify_permissions_and_get_entity(
                 id=template_id,
                 get_method=zen_store().get_run_template,
                 hydrate=True,
             )
+            analytics_handler.metadata = {
+                "project_id": template.project.id,
+            }
 
             verify_permission(
                 resource_type=ResourceType.PIPELINE_DEPLOYMENT,
                 action=Action.CREATE,
+                project_id=template.project.id,
             )
             verify_permission(
-                resource_type=ResourceType.PIPELINE_RUN, action=Action.CREATE
+                resource_type=ResourceType.PIPELINE_RUN,
+                action=Action.CREATE,
+                project_id=template.project.id,
             )
 
             return run_template(

zenml/zen_server/routers/runs_endpoints.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Endpoint definitions for pipeline runs."""
 
-from typing import Any, Dict
+from typing import Any, Dict, Optional, Tuple, Union
 from uuid import UUID
 
 from fastapi import APIRouter, Depends, Security
@@ -32,6 +32,7 @@ from zenml.logger import get_logger
 from zenml.models import (
     Page,
     PipelineRunFilter,
+    PipelineRunRequest,
     PipelineRunResponse,
     PipelineRunUpdate,
     StepRunFilter,
@@ -42,11 +43,15 @@ from zenml.zen_server.exceptions import error_response
 from zenml.zen_server.rbac.endpoint_utils import (
     verify_permissions_and_delete_entity,
     verify_permissions_and_get_entity,
+    verify_permissions_and_get_or_create_entity,
     verify_permissions_and_list_entities,
     verify_permissions_and_update_entity,
 )
 from zenml.zen_server.rbac.models import Action, ResourceType
-from zenml.zen_server.rbac.utils import verify_permission_for_model
+from zenml.zen_server.rbac.utils import (
+    verify_permission_for_model,
+)
+from zenml.zen_server.routers.projects_endpoints import workspace_router
 from zenml.zen_server.utils import (
     handle_exceptions,
     make_dependable,
@@ -63,16 +68,62 @@ router = APIRouter(
 logger = get_logger(__name__)
 
 
+@router.post(
+    "",
+    responses={401: error_response, 409: error_response, 422: error_response},
+)
+# TODO: the workspace scoped endpoint is only kept for dashboard compatibility
+# and can be removed after the migration
+@workspace_router.post(
+    "/{project_name_or_id}" + RUNS,
+    responses={401: error_response, 409: error_response, 422: error_response},
+    deprecated=True,
+    tags=["runs"],
+)
+@handle_exceptions
+def get_or_create_pipeline_run(
+    pipeline_run: PipelineRunRequest,
+    project_name_or_id: Optional[Union[str, UUID]] = None,
+    _: AuthContext = Security(authorize),
+) -> Tuple[PipelineRunResponse, bool]:
+    """Get or create a pipeline run.
+
+    Args:
+        pipeline_run: Pipeline run to create.
+        project_name_or_id: Optional name or ID of the project.
+
+    Returns:
+        The pipeline run and a boolean indicating whether the run was created
+        or not.
+    """
+    if project_name_or_id:
+        project = zen_store().get_project(project_name_or_id)
+        pipeline_run.project = project.id
+
+    return verify_permissions_and_get_or_create_entity(
+        request_model=pipeline_run,
+        get_or_create_method=zen_store().get_or_create_run,
+    )
+
+
 @router.get(
     "",
-    response_model=Page[PipelineRunResponse],
     responses={401: error_response, 404: error_response, 422: error_response},
 )
+# TODO: the workspace scoped endpoint is only kept for dashboard compatibility
+# and can be removed after the migration
+@workspace_router.get(
+    "/{project_name_or_id}" + RUNS,
+    responses={401: error_response, 404: error_response, 422: error_response},
+    deprecated=True,
+    tags=["runs"],
+)
 @handle_exceptions
 def list_runs(
     runs_filter_model: PipelineRunFilter = Depends(
         make_dependable(PipelineRunFilter)
     ),
+    project_name_or_id: Optional[Union[str, UUID]] = None,
     hydrate: bool = False,
     _: AuthContext = Security(authorize),
 ) -> Page[PipelineRunResponse]:
@@ -80,12 +131,16 @@ def list_runs(
 
     Args:
         runs_filter_model: Filter model used for pagination, sorting, filtering.
+        project_name_or_id: Optional name or ID of the project.
         hydrate: Flag deciding whether to hydrate the output model(s)
             by including metadata fields in the response.
 
     Returns:
         The pipeline runs according to query filters.
     """
+    if project_name_or_id:
+        runs_filter_model.project = project_name_or_id
+
     return verify_permissions_and_list_entities(
         filter_model=runs_filter_model,
         resource_type=ResourceType.PIPELINE_RUN,
@@ -96,7 +151,6 @@ def list_runs(
 
 @router.get(
     "/{run_id}",
-    response_model=PipelineRunResponse,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -157,7 +211,6 @@ def get_run(
 
 @router.put(
     "/{run_id}",
-    response_model=PipelineRunResponse,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -206,7 +259,6 @@ def delete_run(
 
 @router.get(
     "/{run_id}" + STEPS,
-    response_model=Page[StepRunResponse],
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -236,7 +288,6 @@ def get_run_steps(
 
 @router.get(
     "/{run_id}" + PIPELINE_CONFIGURATION,
-    response_model=Dict[str, Any],
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -260,7 +311,6 @@ def get_pipeline_configuration(
 
 @router.get(
     "/{run_id}" + STATUS,
-    response_model=ExecutionStatus,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions