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

zenml/zen_server/routers/triggers_endpoints.py

@@ -58,7 +58,6 @@ router = APIRouter(
 
 @router.get(
     "",
-    response_model=Page[TriggerResponse],
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -90,7 +89,6 @@ def list_triggers(
 
 @router.get(
     "/{trigger_id}",
-    response_model=TriggerResponse,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -116,7 +114,6 @@ def get_trigger(
 
 @router.post(
     "",
-    response_model=TriggerResponse,
     responses={401: error_response, 409: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -162,14 +159,12 @@ def create_trigger(
 
     return verify_permissions_and_create_entity(
         request_model=trigger,
-        resource_type=ResourceType.TRIGGER,
         create_method=zen_store().create_trigger,
     )
 
 
 @router.put(
     "/{trigger_id}",
-    response_model=TriggerResponse,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -245,9 +240,11 @@ def delete_trigger(
     Args:
         trigger_id: Name of the trigger.
     """
-    trigger = zen_store().get_trigger(trigger_id=trigger_id)
-    verify_permission_for_model(trigger, action=Action.DELETE)
-    zen_store().delete_trigger(trigger_id=trigger_id)
+    verify_permissions_and_delete_entity(
+        id=trigger_id,
+        get_method=zen_store().get_trigger,
+        delete_method=zen_store().delete_trigger,
+    )
 
 
 executions_router = APIRouter(

zenml/zen_server/routers/users_endpoints.py

@@ -33,6 +33,7 @@ from zenml.exceptions import AuthorizationException, IllegalOperationError
 from zenml.logger import get_logger
 from zenml.models import (
     Page,
+    ProjectScopedResponse,
     UserAuthModel,
     UserFilter,
     UserRequest,
@@ -87,7 +88,6 @@ current_user_router = APIRouter(
 
 @router.get(
     "",
-    response_model=Page[UserResponse],
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -133,7 +133,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
     @router.post(
         "",
-        response_model=UserResponse,
         responses={
             401: error_response,
             409: error_response,
@@ -174,7 +173,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
         # new_user = verify_permissions_and_create_entity(
         #     request_model=user,
-        #     resource_type=ResourceType.USER,
         #     create_method=zen_store().create_user,
         # )
         new_user = zen_store().create_user(user)
@@ -188,7 +186,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
 @router.get(
     "/{user_name_or_id}",
-    response_model=UserResponse,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -233,7 +230,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
     @router.put(
         "/{user_name_or_id}",
-        response_model=UserResponse,
         responses={
             401: error_response,
             404: error_response,
@@ -403,7 +399,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
     @activation_router.put(
         "/{user_name_or_id}" + ACTIVATE,
-        response_model=UserResponse,
         responses={
             401: error_response,
             404: error_response,
@@ -464,7 +459,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
     @router.put(
         "/{user_name_or_id}" + DEACTIVATE,
-        response_model=UserResponse,
         responses={
             401: error_response,
             404: error_response,
@@ -555,7 +549,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
     @router.put(
         "/{user_name_or_id}" + EMAIL_ANALYTICS,
-        response_model=UserResponse,
         responses={
             401: error_response,
             404: error_response,
@@ -608,7 +601,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
 @current_user_router.get(
     "/current-user",
-    response_model=UserResponse,
     responses={401: error_response, 404: error_response, 422: error_response},
 )
 @handle_exceptions
@@ -632,7 +624,6 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
 
     @current_user_router.put(
         "/current-user",
-        response_model=UserResponse,
         responses={
             401: error_response,
             404: error_response,
@@ -752,8 +743,6 @@ if server_config().rbac_enabled:
             )
 
         resource_type = ResourceType(resource_type)
-        resource = Resource(type=resource_type, id=resource_id)
-
         schema_class = get_schema_for_resource_type(resource_type)
         model = zen_store().get_entity_by_id(
             entity_id=resource_id, schema_class=schema_class
@@ -765,6 +754,14 @@ if server_config().rbac_enabled:
                 "not exist."
             )
 
+        project_id = None
+        if isinstance(model, ProjectScopedResponse):
+            project_id = model.project.id
+
+        resource = Resource(
+            type=resource_type, id=resource_id, project_id=project_id
+        )
+
         verify_permission_for_model(model=model, action=Action.SHARE)
         for action in actions:
             # Make sure users aren't able to share permissions they don't have

zenml/zen_server/template_execution/utils.py

@@ -18,8 +18,8 @@ from zenml.config.pipeline_run_configuration import (
 )
 from zenml.config.step_configurations import Step, StepConfiguration
 from zenml.constants import (
+    ENV_ZENML_ACTIVE_PROJECT_ID,
     ENV_ZENML_ACTIVE_STACK_ID,
-    ENV_ZENML_ACTIVE_WORKSPACE_ID,
 )
 from zenml.enums import ExecutionStatus, StackComponentType, StoreType
 from zenml.logger import get_logger
@@ -134,7 +134,7 @@ def run_template(
     ).access_token
 
     environment = {
-        ENV_ZENML_ACTIVE_WORKSPACE_ID: str(new_deployment.workspace.id),
+        ENV_ZENML_ACTIVE_PROJECT_ID: str(new_deployment.project.id),
         ENV_ZENML_ACTIVE_STACK_ID: str(stack.id),
         "ZENML_VERSION": zenml_version,
         "ZENML_STORE_URL": server_url,
@@ -149,9 +149,10 @@ def run_template(
     )
 
     def _task() -> None:
-        pypi_requirements, apt_packages = (
-            requirements_utils.get_requirements_for_stack(stack=stack)
-        )
+        (
+            pypi_requirements,
+            apt_packages,
+        ) = requirements_utils.get_requirements_for_stack(stack=stack)
 
         if build.python_version:
             version_info = version.parse(build.python_version)
@@ -406,8 +407,7 @@ def deployment_request_from_template(
     assert deployment.stack
     assert deployment.build
     deployment_request = PipelineDeploymentRequest(
-        user=user_id,
-        workspace=deployment.workspace.id,
+        project=deployment.project.id,
         run_name_template=config.run_name
         or get_default_run_name(pipeline_name=pipeline_configuration.name),
         pipeline_configuration=pipeline_configuration,
@@ -463,6 +463,7 @@ def get_pipeline_run_analytics_metadata(
     }
 
     return {
+        "project_id": deployment.project.id,
         "store_type": "rest",  # This method is called from within a REST endpoint
         **stack_metadata,
         "total_steps": len(deployment.step_configurations),

zenml/zen_server/utils.py

@@ -26,9 +26,11 @@ from typing import (
     Tuple,
     Type,
     TypeVar,
+    Union,
     cast,
 )
 from urllib.parse import urlparse
+from uuid import UUID
 
 from pydantic import BaseModel, ValidationError
 
@@ -44,6 +46,7 @@ from zenml.constants import (
 from zenml.enums import StoreType
 from zenml.exceptions import IllegalOperationError, OAuthError
 from zenml.logger import get_logger
+from zenml.models.v2.base.scoped import ProjectScopedFilter
 from zenml.plugins.plugin_flavor_registry import PluginFlavorRegistry
 from zenml.zen_server.cache import MemoryCache
 from zenml.zen_server.deploy.deployment import (
@@ -635,3 +638,21 @@ def get_zenml_headers() -> Dict[str, str]:
         headers["zenml-server-url"] = config.server_url
 
     return headers
+
+
+def set_filter_project_scope(
+    filter_model: ProjectScopedFilter,
+    project_name_or_id: Optional[Union[UUID, str]] = None,
+) -> None:
+    """Set the project scope of the filter model.
+
+    Args:
+        filter_model: The filter model to set the scope for.
+        project_name_or_id: The project to set the scope for. If not
+            provided, the project scope is determined from the request
+            project filter or the default project, in that order.
+    """
+    zen_store().set_filter_project_id(
+        filter_model=filter_model,
+        project_name_or_id=project_name_or_id,
+    )

zenml/zen_server/zen_server_api.py

@@ -73,6 +73,8 @@ from zenml.zen_server.routers import (
     pipeline_deployments_endpoints,
     pipelines_endpoints,
     plugin_endpoints,
+    projects_endpoints,
+    run_metadata_endpoints,
     run_templates_endpoints,
     runs_endpoints,
     schedule_endpoints,
@@ -85,11 +87,11 @@ from zenml.zen_server.routers import (
     stack_deployment_endpoints,
     stacks_endpoints,
     steps_endpoints,
+    tag_resource_endpoints,
     tags_endpoints,
     triggers_endpoints,
     users_endpoints,
     webhook_endpoints,
-    workspaces_endpoints,
 )
 from zenml.zen_server.secure_headers import (
     initialize_secure_headers,
@@ -472,6 +474,7 @@ app.include_router(pipelines_endpoints.router)
 app.include_router(pipeline_builds_endpoints.router)
 app.include_router(pipeline_deployments_endpoints.router)
 app.include_router(runs_endpoints.router)
+app.include_router(run_metadata_endpoints.router)
 app.include_router(run_templates_endpoints.router)
 app.include_router(schedule_endpoints.router)
 app.include_router(secrets_endpoints.router)
@@ -487,11 +490,13 @@ app.include_router(stack_components_endpoints.router)
 app.include_router(stack_components_endpoints.types_router)
 app.include_router(steps_endpoints.router)
 app.include_router(tags_endpoints.router)
+app.include_router(tag_resource_endpoints.router)
 app.include_router(triggers_endpoints.router)
 app.include_router(users_endpoints.router)
 app.include_router(users_endpoints.current_user_router)
 app.include_router(webhook_endpoints.router)
-app.include_router(workspaces_endpoints.router)
+app.include_router(projects_endpoints.workspace_router)
+app.include_router(projects_endpoints.router)
 
 # When the auth scheme is set to EXTERNAL, users cannot be managed via the
 # API.

zenml/zen_stores/base_zen_store.py

@@ -33,9 +33,9 @@ from zenml.config.global_config import GlobalConfiguration
 from zenml.config.server_config import ServerConfiguration
 from zenml.config.store_config import StoreConfiguration
 from zenml.constants import (
+    DEFAULT_PROJECT_NAME,
     DEFAULT_STACK_AND_COMPONENT_NAME,
-    DEFAULT_WORKSPACE_NAME,
-    ENV_ZENML_DEFAULT_WORKSPACE_NAME,
+    ENV_ZENML_DEFAULT_PROJECT_NAME,
     ENV_ZENML_SERVER,
     IS_DEBUG_ENV,
 )
@@ -46,6 +46,7 @@ from zenml.enums import (
 from zenml.exceptions import IllegalOperationError
 from zenml.logger import get_logger
 from zenml.models import (
+    ProjectResponse,
     ServerDatabaseType,
     ServerDeploymentType,
     ServerModel,
@@ -53,7 +54,6 @@ from zenml.models import (
     StackResponse,
     UserFilter,
     UserResponse,
-    WorkspaceResponse,
 )
 from zenml.utils.pydantic_utils import before_validator_handler
 from zenml.zen_stores.zen_store_interface import ZenStoreInterface
@@ -292,51 +292,55 @@ class BaseZenStore(
 
     def validate_active_config(
         self,
-        active_workspace_name_or_id: Optional[Union[str, UUID]] = None,
+        active_project_name_or_id: Optional[Union[str, UUID]] = None,
         active_stack_id: Optional[UUID] = None,
         config_name: str = "",
-    ) -> Tuple[WorkspaceResponse, StackResponse]:
+    ) -> Tuple[Optional[ProjectResponse], StackResponse]:
         """Validate the active configuration.
 
-        Call this method to validate the supplied active workspace and active
+        Call this method to validate the supplied active project and active
         stack values.
 
-        This method is guaranteed to return valid workspace ID and stack ID
-        values. If the supplied workspace and stack are not set or are not valid
-        (e.g. they do not exist or are not accessible), the default workspace and
-        default workspace stack will be returned in their stead.
+        This method returns a valid project and stack values. If the
+        supplied project and stack are not set or are not valid (e.g. they
+        do not exist or are not accessible), the default project and default
+        stack will be returned in their stead.
 
         Args:
-            active_workspace_name_or_id: The name or ID of the active workspace.
+            active_project_name_or_id: The name or ID of the active project.
             active_stack_id: The ID of the active stack.
             config_name: The name of the configuration to validate (used in the
                 displayed logs/messages).
 
         Returns:
-            A tuple containing the active workspace and active stack.
+            A tuple containing the active project and active stack.
         """
-        active_workspace: WorkspaceResponse
+        active_project: Optional[ProjectResponse] = None
 
-        if active_workspace_name_or_id:
+        if active_project_name_or_id:
             try:
-                active_workspace = self.get_workspace(
-                    active_workspace_name_or_id
+                active_project = self.get_project(active_project_name_or_id)
+            except (KeyError, IllegalOperationError):
+                active_project_name_or_id = None
+                logger.warning(
+                    f"The current {config_name} active project is no longer "
+                    f"available."
                 )
-            except KeyError:
-                active_workspace = self._get_default_workspace()
 
+        if active_project is None:
+            try:
+                active_project = self._get_default_project()
+            except (KeyError, IllegalOperationError):
                 logger.warning(
-                    f"The current {config_name} active workspace is no longer "
-                    f"available. Resetting the active workspace to "
-                    f"'{active_workspace.name}'."
+                    "An active project is not set. Please set the active "
+                    "project by running `zenml project set "
+                    "<project-name>`."
+                )
+            else:
+                logger.info(
+                    f"Setting the {config_name} active project "
+                    f"to '{active_project.name}'."
                 )
-        else:
-            active_workspace = self._get_default_workspace()
-
-            logger.info(
-                f"Setting the {config_name} active workspace "
-                f"to '{active_workspace.name}'."
-            )
 
         active_stack: StackResponse
 
@@ -351,30 +355,16 @@ class BaseZenStore(
                     "Resetting the active stack to default.",
                     config_name,
                 )
-                active_stack = self._get_default_stack(
-                    workspace_id=active_workspace.id
-                )
-            else:
-                if active_stack.workspace.id != active_workspace.id:
-                    logger.warning(
-                        "The current %s active stack is not part of the active "
-                        "workspace. Resetting the active stack to default.",
-                        config_name,
-                    )
-                    active_stack = self._get_default_stack(
-                        workspace_id=active_workspace.id
-                    )
+                active_stack = self._get_default_stack()
 
         else:
             logger.warning(
                 "Setting the %s active stack to default.",
                 config_name,
             )
-            active_stack = self._get_default_stack(
-                workspace_id=active_workspace.id
-            )
+            active_stack = self._get_default_stack()
 
-        return active_workspace, active_stack
+        return active_project, active_stack
 
     def get_store_info(self) -> ServerModel:
         """Get information about the store.
@@ -432,59 +422,50 @@ class BaseZenStore(
         return self.get_store_info().is_local()
 
     # -----------------------------
-    # Default workspaces and stacks
+    # Default projects and stacks
     # -----------------------------
 
     @property
-    def _default_workspace_name(self) -> str:
-        """Get the default workspace name.
+    def _default_project_name(self) -> str:
+        """Get the default project name.
 
         Returns:
-            The default workspace name.
+            The default project name.
         """
-        return os.getenv(
-            ENV_ZENML_DEFAULT_WORKSPACE_NAME, DEFAULT_WORKSPACE_NAME
-        )
+        return os.getenv(ENV_ZENML_DEFAULT_PROJECT_NAME, DEFAULT_PROJECT_NAME)
 
-    def _get_default_workspace(self) -> WorkspaceResponse:
-        """Get the default workspace.
+    def _get_default_project(self) -> ProjectResponse:
+        """Get the default project.
 
         Raises:
-            KeyError: If the default workspace doesn't exist.
+            KeyError: If the default project doesn't exist.
 
         Returns:
-            The default workspace.
+            The default project.
         """
         try:
-            return self.get_workspace(self._default_workspace_name)
+            return self.get_project(self._default_project_name)
         except KeyError:
-            raise KeyError("Unable to find default workspace.")
+            raise KeyError("Unable to find default project.")
 
     def _get_default_stack(
         self,
-        workspace_id: UUID,
     ) -> StackResponse:
-        """Get the default stack for a user in a workspace.
-
-        Args:
-            workspace_id: ID of the workspace.
+        """Get the default stack.
 
         Returns:
-            The default stack in the workspace.
+            The default stack.
 
         Raises:
-            KeyError: if the workspace or default stack doesn't exist.
+            KeyError: if the default stack doesn't exist.
         """
         default_stacks = self.list_stacks(
             StackFilter(
-                workspace_id=workspace_id,
                 name=DEFAULT_STACK_AND_COMPONENT_NAME,
             )
         )
         if default_stacks.total == 0:
-            raise KeyError(
-                f"No default stack found in workspace {workspace_id}."
-            )
+            raise KeyError("No default stack found.")
         return default_stacks.items[0]
 
     def get_external_user(self, user_id: UUID) -> UserResponse: