zenml-nightly 0.80.0.dev20250326__py3-none-any.whl → 0.80.0.dev20250328__py3-none-any.whl

zenml/integrations/whylogs/__init__.py

@@ -50,11 +50,13 @@ class WhylogsIntegration(Integration):
         return [WhylogsDataValidatorFlavor]
 
     @classmethod
-    def get_requirements(cls, target_os: Optional[str] = None) -> List[str]:
+    def get_requirements(cls, target_os: Optional[str] = None, python_version: Optional[str] = None
+    ) -> List[str]:
         """Method to get the requirements for the integration.
 
         Args:
             target_os: The target operating system to get the requirements for.
+            python_version: The Python version to use for the requirements.
 
         Returns:
             A list of requirements.
@@ -62,6 +64,6 @@ class WhylogsIntegration(Integration):
         from zenml.integrations.pandas import PandasIntegration
 
         return cls.REQUIREMENTS + \
-            PandasIntegration.get_requirements(target_os=target_os)
+            PandasIntegration.get_requirements(target_os=target_os, python_version=python_version)
 
 

zenml/models/v2/core/user.py

@@ -203,6 +203,10 @@ class UserUpdate(UserBase, BaseUpdate):
         "accounts. Required when updating the password.",
         max_length=STR_FIELD_MAX_LENGTH,
     )
+    default_project_id: Optional[UUID] = Field(
+        default=None,
+        title="The default project ID for the user.",
+    )
 
     @model_validator(mode="after")
     def user_email_updates(self) -> "UserUpdate":
@@ -279,6 +283,10 @@ class UserResponseBody(BaseDatedResponseBody):
     is_admin: bool = Field(
         title="Whether the account is an administrator.",
     )
+    default_project_id: Optional[UUID] = Field(
+        default=None,
+        title="The default project ID for the user.",
+    )
 
 
 class UserResponseMetadata(BaseResponseMetadata):
@@ -422,6 +430,15 @@ class UserResponse(
         """
         return self.get_metadata().user_metadata
 
+    @property
+    def default_project_id(self) -> Optional[UUID]:
+        """The `default_project_id` property.
+
+        Returns:
+            the value of the property.
+        """
+        return self.get_body().default_project_id
+
     # Helper methods
     @classmethod
     def _get_crypt_context(cls) -> "CryptContext":

zenml/utils/requirements_utils.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Requirement utils."""
 
-from typing import TYPE_CHECKING, List, Set, Tuple
+from typing import TYPE_CHECKING, List, Optional, Set, Tuple
 
 from zenml.integrations.utils import get_integration_for_module
 
@@ -23,11 +23,13 @@ if TYPE_CHECKING:
 
 def get_requirements_for_stack(
     stack: "StackResponse",
+    python_version: Optional[str] = None,
 ) -> Tuple[List[str], List[str]]:
     """Get requirements for a stack model.
 
     Args:
         stack: The stack for which to get the requirements.
+        python_version: The Python version to use for the requirements.
 
     Returns:
         Tuple of PyPI and APT requirements of the stack.
@@ -41,7 +43,10 @@ def get_requirements_for_stack(
         (
             component_pypi_requirements,
             component_apt_packages,
-        ) = get_requirements_for_component(component=component)
+        ) = get_requirements_for_component(
+            component=component,
+            python_version=python_version,
+        )
         pypi_requirements = pypi_requirements.union(
             component_pypi_requirements
         )
@@ -52,11 +57,13 @@ def get_requirements_for_stack(
 
 def get_requirements_for_component(
     component: "ComponentResponse",
+    python_version: Optional[str] = None,
 ) -> Tuple[List[str], List[str]]:
     """Get requirements for a component model.
 
     Args:
         component: The component for which to get the requirements.
+        python_version: The Python version to use for the requirements.
 
     Returns:
         Tuple of PyPI and APT requirements of the component.
@@ -66,6 +73,8 @@ def get_requirements_for_component(
     )
 
     if integration:
-        return integration.get_requirements(), integration.APT_PACKAGES
+        return integration.get_requirements(
+            python_version=python_version
+        ), integration.APT_PACKAGES
     else:
         return [], []

zenml/zen_server/routers/users_endpoints.py

@@ -65,6 +65,11 @@ from zenml.zen_server.utils import (
 
 logger = get_logger(__name__)
 
+pass_change_limiter = RequestLimiter(
+    day_limit=server_config().login_rate_limit_day,
+    minute_limit=server_config().login_rate_limit_minute,
+)
+
 router = APIRouter(
     prefix=API + VERSION_1 + USERS,
     tags=["users"],
@@ -223,179 +228,6 @@ def get_user(
 # When the auth scheme is set to EXTERNAL, users cannot be updated via the
 # API.
 if server_config().auth_scheme != AuthScheme.EXTERNAL:
-    pass_change_limiter = RequestLimiter(
-        day_limit=server_config().login_rate_limit_day,
-        minute_limit=server_config().login_rate_limit_minute,
-    )
-
-    @router.put(
-        "/{user_name_or_id}",
-        responses={
-            401: error_response,
-            404: error_response,
-            422: error_response,
-        },
-    )
-    @handle_exceptions
-    def update_user(
-        user_name_or_id: Union[str, UUID],
-        user_update: UserUpdate,
-        request: Request,
-        auth_context: AuthContext = Security(authorize),
-    ) -> UserResponse:
-        """Updates a specific user.
-
-        Args:
-            user_name_or_id: Name or ID of the user.
-            user_update: the user to use for the update.
-            request: The request object.
-            auth_context: Authentication context.
-
-        Returns:
-            The updated user.
-
-        Raises:
-            IllegalOperationError: if the user tries change admin status,
-                while not an admin, if the user tries to change the password
-                of another user, or if the user tries to change their own
-                password without providing the old password or providing
-                an incorrect old password.
-        """
-        user = zen_store().get_user(user_name_or_id)
-
-        # Use a separate object to compute the update that will be applied to
-        # the user to avoid giving the API requester direct control over the
-        # user attributes that are updated.
-        #
-        # Exclude attributes that cannot be updated through this endpoint:
-        #
-        # - activation_token
-        # - external_user_id
-        # - old_password
-        #
-        # Exclude things that are not always safe to update and need to be
-        # validated first:
-        #
-        # - admin
-        # - active
-        # - password
-        # - email_opted_in + email
-        #
-        safe_user_update = user_update.create_copy(
-            exclude={
-                "activation_token",
-                "external_user_id",
-                "is_admin",
-                "active",
-                "password",
-                "old_password",
-                "email_opted_in",
-                "email",
-            },
-        )
-
-        if user.id != auth_context.user.id:
-            verify_admin_status_if_no_rbac(
-                auth_context.user.is_admin, "update other user account"
-            )
-            # verify_permission_for_model(
-            #     user,
-            #     action=Action.UPDATE,
-            # )
-
-        # Validate a password change
-        if user_update.password is not None:
-            if user.id != auth_context.user.id:
-                raise IllegalOperationError(
-                    "Users cannot change the password of other users. Use the "
-                    "account deactivation and activation flow instead."
-                )
-
-            # If the user is updating their own password, we need to verify
-            # the old password
-            if user_update.old_password is None:
-                raise IllegalOperationError(
-                    "The current password must be supplied when changing the "
-                    "password."
-                )
-
-            with pass_change_limiter.limit_failed_requests(request):
-                auth_user = zen_store().get_auth_user(user_name_or_id)
-                if not UserAuthModel.verify_password(
-                    user_update.old_password, auth_user
-                ):
-                    raise IllegalOperationError(
-                        "The current password is incorrect."
-                    )
-
-            # Accept the password update
-            safe_user_update.password = user_update.password
-
-        # Validate an admin status change
-        if (
-            user_update.is_admin is not None
-            and user.is_admin != user_update.is_admin
-        ):
-            if user.id == auth_context.user.id:
-                raise IllegalOperationError(
-                    "Cannot change the admin status of your own user account."
-                )
-
-            if (
-                user.id != auth_context.user.id
-                and not auth_context.user.is_admin
-            ):
-                raise IllegalOperationError(
-                    "Only admins are allowed to change the admin status of "
-                    "other user accounts."
-                )
-
-            # Accept the admin status update
-            safe_user_update.is_admin = user_update.is_admin
-
-        # Validate an active status change
-        if (
-            user_update.active is not None
-            and user.active != user_update.active
-        ):
-            if user.id == auth_context.user.id:
-                raise IllegalOperationError(
-                    "Cannot change the active status of your own user account."
-                )
-
-            if (
-                user.id != auth_context.user.id
-                and not auth_context.user.is_admin
-            ):
-                raise IllegalOperationError(
-                    "Only admins are allowed to change the active status of "
-                    "other user accounts."
-                )
-
-            # Accept the admin status update
-            safe_user_update.is_admin = user_update.is_admin
-
-        # Validate changes to private user account information
-        if (
-            user_update.email_opted_in is not None
-            or user_update.email is not None
-        ):
-            if user.id != auth_context.user.id:
-                raise IllegalOperationError(
-                    "Cannot change the private user account information for "
-                    "another user account."
-                )
-
-            # Accept the private user account information update
-            if safe_user_update.email_opted_in is not None:
-                safe_user_update.email_opted_in = user_update.email_opted_in
-                safe_user_update.email = user_update.email
-
-        updated_user = zen_store().update_user(
-            user_id=user.id,
-            user_update=safe_user_update,
-        )
-        return dehydrate_response_model(updated_user)
 
     @activation_router.put(
         "/{user_name_or_id}" + ACTIVATE,
@@ -599,6 +431,170 @@ if server_config().auth_scheme != AuthScheme.EXTERNAL:
             )
 
 
+@router.put(
+    "/{user_name_or_id}",
+    responses={
+        401: error_response,
+        404: error_response,
+        422: error_response,
+    },
+)
+@handle_exceptions
+def update_user(
+    user_name_or_id: Union[str, UUID],
+    user_update: UserUpdate,
+    request: Request,
+    auth_context: AuthContext = Security(authorize),
+) -> UserResponse:
+    """Updates a specific user.
+
+    Args:
+        user_name_or_id: Name or ID of the user.
+        user_update: the user to use for the update.
+        request: The request object.
+        auth_context: Authentication context.
+
+    Returns:
+        The updated user.
+
+    Raises:
+        IllegalOperationError: if the user tries change admin status,
+            while not an admin, if the user tries to change the password
+            of another user, or if the user tries to change their own
+            password without providing the old password or providing
+            an incorrect old password.
+    """
+    if server_config().auth_scheme == AuthScheme.EXTERNAL:
+        # For external auth, we only allow updating the default project
+        user_update = UserUpdate(
+            default_project_id=user_update.default_project_id,
+        )
+
+    user = zen_store().get_user(user_name_or_id)
+
+    # Use a separate object to compute the update that will be applied to
+    # the user to avoid giving the API requester direct control over the
+    # user attributes that are updated.
+    #
+    # Exclude attributes that cannot be updated through this endpoint:
+    #
+    # - activation_token
+    # - external_user_id
+    # - old_password
+    #
+    # Exclude things that are not always safe to update and need to be
+    # validated first:
+    #
+    # - admin
+    # - active
+    # - password
+    # - email_opted_in + email
+    #
+    safe_user_update = user_update.create_copy(
+        exclude={
+            "activation_token",
+            "external_user_id",
+            "is_admin",
+            "active",
+            "password",
+            "old_password",
+            "email_opted_in",
+            "email",
+        },
+    )
+
+    if user.id != auth_context.user.id:
+        verify_admin_status_if_no_rbac(
+            auth_context.user.is_admin, "update other user account"
+        )
+        # verify_permission_for_model(
+        #     user,
+        #     action=Action.UPDATE,
+        # )
+
+    # Validate a password change
+    if user_update.password is not None:
+        if user.id != auth_context.user.id:
+            raise IllegalOperationError(
+                "Users cannot change the password of other users. Use the "
+                "account deactivation and activation flow instead."
+            )
+
+        # If the user is updating their own password, we need to verify
+        # the old password
+        if user_update.old_password is None:
+            raise IllegalOperationError(
+                "The current password must be supplied when changing the "
+                "password."
+            )
+
+        with pass_change_limiter.limit_failed_requests(request):
+            auth_user = zen_store().get_auth_user(user_name_or_id)
+            if not UserAuthModel.verify_password(
+                user_update.old_password, auth_user
+            ):
+                raise IllegalOperationError(
+                    "The current password is incorrect."
+                )
+
+        # Accept the password update
+        safe_user_update.password = user_update.password
+
+    # Validate an admin status change
+    if (
+        user_update.is_admin is not None
+        and user.is_admin != user_update.is_admin
+    ):
+        if user.id == auth_context.user.id:
+            raise IllegalOperationError(
+                "Cannot change the admin status of your own user account."
+            )
+
+        if user.id != auth_context.user.id and not auth_context.user.is_admin:
+            raise IllegalOperationError(
+                "Only admins are allowed to change the admin status of "
+                "other user accounts."
+            )
+
+        # Accept the admin status update
+        safe_user_update.is_admin = user_update.is_admin
+
+    # Validate an active status change
+    if user_update.active is not None and user.active != user_update.active:
+        if user.id == auth_context.user.id:
+            raise IllegalOperationError(
+                "Cannot change the active status of your own user account."
+            )
+
+        if user.id != auth_context.user.id and not auth_context.user.is_admin:
+            raise IllegalOperationError(
+                "Only admins are allowed to change the active status of "
+                "other user accounts."
+            )
+
+        # Accept the admin status update
+        safe_user_update.is_admin = user_update.is_admin
+
+    # Validate changes to private user account information
+    if user_update.email_opted_in is not None or user_update.email is not None:
+        if user.id != auth_context.user.id:
+            raise IllegalOperationError(
+                "Cannot change the private user account information for "
+                "another user account."
+            )
+
+        # Accept the private user account information update
+        if safe_user_update.email_opted_in is not None:
+            safe_user_update.email_opted_in = user_update.email_opted_in
+            safe_user_update.email = user_update.email
+
+    updated_user = zen_store().update_user(
+        user_id=user.id,
+        user_update=safe_user_update,
+    )
+    return dehydrate_response_model(updated_user)
+
+
 @current_user_router.get(
     "/current-user",
     responses={401: error_response, 404: error_response, 422: error_response},

zenml/zen_server/template_execution/utils.py

@@ -149,11 +149,6 @@ def run_template(
     )
 
     def _task() -> None:
-        (
-            pypi_requirements,
-            apt_packages,
-        ) = requirements_utils.get_requirements_for_stack(stack=stack)
-
         if build.python_version:
             version_info = version.parse(build.python_version)
             python_version = f"{version_info.major}.{version_info.minor}"
@@ -162,6 +157,13 @@ def run_template(
                 f"{sys.version_info.major}.{sys.version_info.minor}"
             )
 
+        (
+            pypi_requirements,
+            apt_packages,
+        ) = requirements_utils.get_requirements_for_stack(
+            stack=stack, python_version=python_version
+        )
+
         dockerfile = generate_dockerfile(
             pypi_requirements=pypi_requirements,
             apt_packages=apt_packages,
@@ -169,6 +171,10 @@ def run_template(
             python_version=python_version,
         )
 
+        # building a docker image with requirements and apt packages from the
+        # stack only (no code). Ideally, only orchestrator requirements should
+        # be added to the docker image, but we have to instantiate the entire
+        # stack to get the orchestrator to run pipelines.
         image_hash = generate_image_hash(dockerfile=dockerfile)
 
         runner_image = workload_manager().build_and_push_image(
@@ -182,6 +188,9 @@ def run_template(
             workload_id=new_deployment.id,
             message="Starting pipeline run.",
         )
+
+        # could do this same thing with a step operator, but we need some
+        # minor changes to the abstract interface to support that.
         workload_manager().run(
             workload_id=new_deployment.id,
             image=runner_image,

zenml/zen_stores/base_zen_store.py

@@ -22,7 +22,6 @@ from typing import (
     Optional,
     Tuple,
     Type,
-    Union,
 )
 from uuid import UUID
 
@@ -46,6 +45,7 @@ from zenml.enums import (
 from zenml.exceptions import IllegalOperationError
 from zenml.logger import get_logger
 from zenml.models import (
+    ProjectFilter,
     ProjectResponse,
     ServerDatabaseType,
     ServerDeploymentType,
@@ -291,7 +291,7 @@ class BaseZenStore(
 
     def validate_active_config(
         self,
-        active_project_name_or_id: Optional[Union[str, UUID]] = None,
+        active_project_id: Optional[UUID] = None,
         active_stack_id: Optional[UUID] = None,
         config_name: str = "",
     ) -> Tuple[Optional[ProjectResponse], StackResponse]:
@@ -306,7 +306,7 @@ class BaseZenStore(
         stack will be returned in their stead.
 
         Args:
-            active_project_name_or_id: The name or ID of the active project.
+            active_project_id: The 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).
@@ -316,30 +316,62 @@ class BaseZenStore(
         """
         active_project: Optional[ProjectResponse] = None
 
-        if active_project_name_or_id:
+        if active_project_id:
             try:
-                active_project = self.get_project(active_project_name_or_id)
+                active_project = self.get_project(active_project_id)
             except (KeyError, IllegalOperationError):
-                active_project_name_or_id = None
+                active_project_id = None
                 logger.warning(
                     f"The current {config_name} active project is no longer "
                     f"available."
                 )
 
+        if active_project is None:
+            user = self.get_user()
+            if user.default_project_id:
+                try:
+                    active_project = self.get_project(user.default_project_id)
+                except (KeyError, IllegalOperationError):
+                    logger.warning(
+                        "The default project %s for the active user is no longer "
+                        "available.",
+                        user.default_project_id,
+                    )
+                else:
+                    logger.info(
+                        f"Setting the {config_name} active project "
+                        f"to '{active_project.name}'."
+                    )
+
         if active_project is None:
             try:
-                active_project = self._get_default_project()
-            except (KeyError, IllegalOperationError):
+                projects = self.list_projects(
+                    project_filter_model=ProjectFilter()
+                )
+            except Exception:
+                # There was some failure, we force the user to set the active
+                # project manually
                 logger.warning(
                     "An active project is not set. Please set the active "
-                    "project by running `zenml project set "
-                    "<project-name>`."
+                    "project by running `zenml project set <NAME>`."
                 )
             else:
-                logger.info(
-                    f"Setting the {config_name} active project "
-                    f"to '{active_project.name}'."
-                )
+                if len(projects) == 0:
+                    logger.warning(
+                        "No available projects. Please create a project by "
+                        "running `zenml project register <NAME> --set`."
+                    )
+                elif len(projects) == 1:
+                    active_project = projects.items[0]
+                    logger.info(
+                        f"Setting the {config_name} active project "
+                        f"to '{active_project.name}'."
+                    )
+                else:
+                    logger.warning(
+                        "Multiple projects are available. Please set the "
+                        "active project by running `zenml project set <NAME>`."
+                    )
 
         active_stack: StackResponse
 

zenml/zen_stores/migrations/versions/1f1105204aaf_add_user_default_project.py

@@ -0,0 +1,51 @@
+"""Add user default project [1f1105204aaf].
+
+Revision ID: 1f1105204aaf
+Revises: 0.80.0
+Create Date: 2025-03-25 11:11:13.480745
+
+"""
+
+import sqlalchemy as sa
+import sqlmodel
+from alembic import op
+
+# revision identifiers, used by Alembic.
+revision = "1f1105204aaf"
+down_revision = "0.80.0"
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    """Upgrade database schema and/or data, creating a new revision."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("user", schema=None) as batch_op:
+        batch_op.add_column(
+            sa.Column(
+                "default_project_id",
+                sqlmodel.sql.sqltypes.GUID(),
+                nullable=True,
+            )
+        )
+        batch_op.create_foreign_key(
+            "fk_user_default_project_id_project",
+            "project",
+            ["default_project_id"],
+            ["id"],
+            ondelete="SET NULL",
+        )
+
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    """Downgrade database schema and/or data back to the previous revision."""
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table("user", schema=None) as batch_op:
+        batch_op.drop_constraint(
+            "fk_user_default_project_id_project", type_="foreignkey"
+        )
+        batch_op.drop_column("default_project_id")
+
+    # ### end Alembic commands ###