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

zenml/config/global_config.py

@@ -48,7 +48,7 @@ from zenml.logger import get_logger
 from zenml.utils import io_utils, yaml_utils
 
 if TYPE_CHECKING:
-    from zenml.models import StackResponse, WorkspaceResponse
+    from zenml.models import ProjectResponse, StackResponse
     from zenml.zen_stores.base_zen_store import BaseZenStore
 
 logger = get_logger(__name__)
@@ -113,7 +113,7 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
             global config.
         store: Store configuration.
         active_stack_id: The ID of the active stack.
-        active_workspace_name: The name of the active workspace.
+        active_project_name: The name of the active project.
     """
 
     user_id: uuid.UUID = Field(default_factory=uuid.uuid4)
@@ -123,10 +123,10 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
     version: Optional[str] = None
     store: Optional[SerializeAsAny[StoreConfiguration]] = None
     active_stack_id: Optional[uuid.UUID] = None
-    active_workspace_name: Optional[str] = None
+    active_project_name: Optional[str] = None
 
     _zen_store: Optional["BaseZenStore"] = None
-    _active_workspace: Optional["WorkspaceResponse"] = None
+    _active_project: Optional["ProjectResponse"] = None
     _active_stack: Optional["StackResponse"] = None
 
     def __init__(self, **data: Any) -> None:
@@ -385,20 +385,25 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
     def _sanitize_config(self) -> None:
         """Sanitize and save the global configuration.
 
-        This method is called to ensure that the active stack and workspace
+        This method is called to ensure that the active stack and project
         are set to their default values, if possible.
         """
         # If running in a ZenML server environment, the active stack and
-        # workspace are not relevant
+        # project are not relevant
         if ENV_ZENML_SERVER in os.environ:
             return
-        active_workspace, active_stack = self.zen_store.validate_active_config(
-            self.active_workspace_name,
+        active_project, active_stack = self.zen_store.validate_active_config(
+            self.active_project_name,
             self.active_stack_id,
             config_name="global",
         )
-        self.active_workspace_name = active_workspace.name
-        self._active_workspace = active_workspace
+        if active_project:
+            self.active_project_name = active_project.name
+            self._active_project = active_project
+        else:
+            self.active_project_name = None
+            self._active_project = None
+
         self.set_active_stack(active_stack)
 
     @property
@@ -714,22 +719,22 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
 
         return self._zen_store
 
-    def set_active_workspace(
-        self, workspace: "WorkspaceResponse"
-    ) -> "WorkspaceResponse":
-        """Set the workspace for the local client.
+    def set_active_project(
+        self, project: "ProjectResponse"
+    ) -> "ProjectResponse":
+        """Set the project for the local client.
 
         Args:
-            workspace: The workspace to set active.
+            project: The project to set active.
 
         Returns:
-            The workspace that was set active.
+            The project that was set active.
         """
-        self.active_workspace_name = workspace.name
-        self._active_workspace = workspace
-        # Sanitize the global configuration to reflect the new workspace
+        self.active_project_name = project.name
+        self._active_project = project
+        # Sanitize the global configuration to reflect the new project
         self._sanitize_config()
-        return workspace
+        return project
 
     def set_active_stack(self, stack: "StackResponse") -> None:
         """Set the active stack for the local client.
@@ -740,35 +745,41 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
         self.active_stack_id = stack.id
         self._active_stack = stack
 
-    def get_active_workspace(self) -> "WorkspaceResponse":
-        """Get a model of the active workspace for the local client.
+    def get_active_project(self) -> "ProjectResponse":
+        """Get a model of the active project for the local client.
 
         Returns:
-            The model of the active workspace.
+            The model of the active project.
         """
-        workspace_name = self.get_active_workspace_name()
+        project_name = self.get_active_project_name()
 
-        if self._active_workspace is not None:
-            return self._active_workspace
+        if self._active_project is not None:
+            return self._active_project
 
-        workspace = self.zen_store.get_workspace(
-            workspace_name_or_id=workspace_name,
+        project = self.zen_store.get_project(
+            project_name_or_id=project_name,
         )
-        return self.set_active_workspace(workspace)
-
-    def get_active_workspace_name(self) -> str:
-        """Get the name of the active workspace.
+        return self.set_active_project(project)
 
-        If the active workspace doesn't exist yet, the ZenStore is reinitialized.
+    def get_active_project_name(self) -> str:
+        """Get the name of the active project.
 
         Returns:
-            The name of the active workspace.
+            The name of the active project.
+
+        Raises:
+            RuntimeError: If the active project is not set.
         """
-        if self.active_workspace_name is None:
+        if self.active_project_name is None:
             _ = self.zen_store
-            assert self.active_workspace_name is not None
+            if self.active_project_name is None:
+                raise RuntimeError(
+                    "No project is currently set as active. Please set the "
+                    "active project using the `zenml project set` CLI "
+                    "command."
+                )
 
-        return self.active_workspace_name
+        return self.active_project_name
 
     def get_active_stack_id(self) -> UUID:
         """Get the ID of the active stack.

zenml/config/pipeline_configurations.py

@@ -14,7 +14,7 @@
 """Pipeline configuration classes."""
 
 from datetime import datetime
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
 
 from pydantic import SerializeAsAny, field_validator
 
@@ -23,6 +23,7 @@ from zenml.config.retry_config import StepRetryConfig
 from zenml.config.source import SourceWithValidator
 from zenml.config.strict_base_model import StrictBaseModel
 from zenml.model.model import Model
+from zenml.utils.tag_utils import Tag
 from zenml.utils.time_utils import utc_now
 
 if TYPE_CHECKING:
@@ -41,7 +42,7 @@ class PipelineConfigurationUpdate(StrictBaseModel):
     enable_artifact_visualization: Optional[bool] = None
     enable_step_logs: Optional[bool] = None
     settings: Dict[str, SerializeAsAny[BaseSettings]] = {}
-    tags: Optional[List[str]] = None
+    tags: Optional[List[Union[str, "Tag"]]] = None
     extra: Dict[str, Any] = {}
     failure_hook_source: Optional[SourceWithValidator] = None
     success_hook_source: Optional[SourceWithValidator] = None

zenml/config/pipeline_run_configuration.py

@@ -27,6 +27,7 @@ from zenml.config.strict_base_model import StrictBaseModel
 from zenml.model.model import Model
 from zenml.models import PipelineBuildBase
 from zenml.utils import pydantic_utils
+from zenml.utils.tag_utils import Tag
 
 
 class PipelineRunConfiguration(
@@ -45,7 +46,7 @@ class PipelineRunConfiguration(
     )
     steps: Dict[str, StepConfigurationUpdate] = {}
     settings: Dict[str, SerializeAsAny[BaseSettings]] = {}
-    tags: Optional[List[str]] = None
+    tags: Optional[List[Union[str, Tag]]] = None
     extra: Dict[str, Any] = {}
     model: Optional[Model] = None
     parameters: Optional[Dict[str, Any]] = None

zenml/config/secret_reference_mixin.py

@@ -115,7 +115,7 @@ class SecretReferenceMixin(BaseModel):
 
         # Try to resolve the secret using the secret store
         try:
-            secret = Client().get_secret_by_name_and_scope(
+            secret = Client().get_secret_by_name_and_private_status(
                 name=secret_ref.name,
             )
         except (KeyError, NotImplementedError):

zenml/constants.py

@@ -143,13 +143,13 @@ ENV_ZENML_REPOSITORY_PATH = "ZENML_REPOSITORY_PATH"
 ENV_ZENML_PREVENT_PIPELINE_EXECUTION = "ZENML_PREVENT_PIPELINE_EXECUTION"
 ENV_ZENML_ENABLE_RICH_TRACEBACK = "ZENML_ENABLE_RICH_TRACEBACK"
 ENV_ZENML_ACTIVE_STACK_ID = "ZENML_ACTIVE_STACK_ID"
-ENV_ZENML_ACTIVE_WORKSPACE_ID = "ZENML_ACTIVE_WORKSPACE_ID"
+ENV_ZENML_ACTIVE_PROJECT_ID = "ZENML_ACTIVE_PROJECT_ID"
 ENV_ZENML_SUPPRESS_LOGS = "ZENML_SUPPRESS_LOGS"
 ENV_ZENML_ENABLE_REPO_INIT_WARNINGS = "ZENML_ENABLE_REPO_INIT_WARNINGS"
 ENV_ZENML_SECRET_VALIDATION_LEVEL = "ZENML_SECRET_VALIDATION_LEVEL"
 ENV_ZENML_DEFAULT_USER_NAME = "ZENML_DEFAULT_USER_NAME"
 ENV_ZENML_DEFAULT_USER_PASSWORD = "ZENML_DEFAULT_USER_PASSWORD"
-ENV_ZENML_DEFAULT_WORKSPACE_NAME = "ZENML_DEFAULT_WORKSPACE_NAME"
+ENV_ZENML_DEFAULT_PROJECT_NAME = "ZENML_DEFAULT_PROJECT_NAME"
 ENV_ZENML_STORE_PREFIX = "ZENML_STORE_"
 ENV_ZENML_SECRETS_STORE_PREFIX = "ZENML_SECRETS_STORE_"
 ENV_ZENML_BACKUP_SECRETS_STORE_PREFIX = "ZENML_BACKUP_SECRETS_STORE_"
@@ -163,7 +163,6 @@ ENV_ZENML_PAGINATION_DEFAULT_LIMIT = "ZENML_PAGINATION_DEFAULT_LIMIT"
 ENV_ZENML_DISABLE_CLIENT_SERVER_MISMATCH_WARNING = (
     "ZENML_DISABLE_CLIENT_SERVER_MISMATCH_WARNING"
 )
-ENV_ZENML_DISABLE_WORKSPACE_WARNINGS = "ZENML_DISABLE_WORKSPACE_WARNINGS"
 ENV_ZENML_SKIP_IMAGE_BUILDER_DEFAULT = "ZENML_SKIP_IMAGE_BUILDER_DEFAULT"
 ENV_ZENML_SKIP_STACK_VALIDATION = "ZENML_SKIP_STACK_VALIDATION"
 ENV_ZENML_SERVER = "ZENML_SERVER"
@@ -240,7 +239,7 @@ SQL_STORE_BACKUP_DIRECTORY_NAME = "database_backup"
 
 DEFAULT_USERNAME = "default"
 DEFAULT_PASSWORD = ""
-DEFAULT_WORKSPACE_NAME = "default"
+DEFAULT_PROJECT_NAME = "default"
 DEFAULT_STACK_AND_COMPONENT_NAME = "default"
 
 # Rich config
@@ -331,7 +330,6 @@ DEFAULT_ZENML_SERVER_REPORT_USER_ACTIVITY_TO_DB_SECONDS = 30
 DEFAULT_ZENML_SERVER_MAX_REQUEST_BODY_SIZE_IN_BYTES = 256 * 1024 * 1024
 
 DEFAULT_REPORTABLE_RESOURCES = ["pipeline", "pipeline_run", "model"]
-REQUIRES_CUSTOM_RESOURCE_REPORTING = ["pipeline", "pipeline_run"]
 
 # API Endpoint paths:
 ACTIVATE = "/activate"
@@ -358,7 +356,6 @@ EMAIL_ANALYTICS = "/email-opt-in"
 EVENT_FLAVORS = "/event-flavors"
 EVENT_SOURCES = "/event-sources"
 FLAVORS = "/flavors"
-GET_OR_CREATE = "/get-or-create"
 HEALTH = "/health"
 INFO = "/info"
 LOAD_INFO = "/load-info"
@@ -402,6 +399,7 @@ STATUS = "/status"
 STEP_CONFIGURATION = "/step-configuration"
 STEPS = "/steps"
 TAGS = "/tags"
+TAG_RESOURCES = "/tag_resources"
 TRIGGERS = "/triggers"
 TRIGGER_EXECUTIONS = "/trigger_executions"
 ONBOARDING_STATE = "/onboarding_state"
@@ -411,6 +409,7 @@ VERSION_1 = "/v1"
 VISUALIZE = "/visualize"
 WEBHOOKS = "/webhooks"
 WORKSPACES = "/workspaces"
+PROJECTS = "/projects"
 
 # model metadata yaml file name
 MODEL_METADATA_YAML_FILE_NAME = "model_metadata.yaml"
@@ -452,6 +451,7 @@ STACK_RECIPES_GITHUB_REPO = "https://github.com/zenml-io/mlops-stacks.git"
 
 # Parameters for internal ZenML Models
 TEXT_FIELD_MAX_LENGTH = 65535
+STR_ID_FIELD_MAX_LENGTH = 50
 STR_FIELD_MAX_LENGTH = 255
 MEDIUMTEXT_MAX_LENGTH = 2**24 - 1
 

zenml/enums.py

@@ -135,13 +135,6 @@ class StackComponentType(StrEnum):
         return f"{self.value}s"
 
 
-class SecretScope(StrEnum):
-    """Enum for the scope of a secret."""
-
-    WORKSPACE = "workspace"
-    USER = "user"
-
-
 class StoreType(StrEnum):
     """Zen Store Backend Types."""
 

zenml/event_hub/event_hub.py

@@ -126,7 +126,9 @@ class InternalEventHub(BaseEventHub):
         triggers: List[TriggerResponse] = depaginate(
             self.zen_store.list_triggers,
             trigger_filter_model=TriggerFilter(
-                event_source_id=event_source.id, is_active=True
+                project=event_source.project.id,
+                event_source_id=event_source.id,
+                is_active=True,
             ),
             hydrate=True,
         )

zenml/exceptions.py

@@ -172,34 +172,10 @@ class EntityCreationError(ZenMLBaseException, RuntimeError):
     """Raised when failing to create an entity."""
 
 
-class ActionExistsError(EntityExistsError):
-    """Raised when registering an action with a name that already exists."""
-
-
-class TriggerExistsError(EntityExistsError):
-    """Raised when registering a trigger with name that already exists."""
-
-
 class WebhookInactiveError(ZenMLBaseException):
     """Raised when source is inactive."""
 
 
-class StackExistsError(EntityExistsError):
-    """Raised when trying to register a stack with name that already exists."""
-
-
-class StackComponentExistsError(EntityExistsError):
-    """Raised when trying to register a stack component with existing name."""
-
-
-class EventSourceExistsError(EntityExistsError):
-    """Raised when trying to register an event source with existing name."""
-
-
-class SecretExistsError(EntityExistsError):
-    """Raised when trying to register a secret with existing name."""
-
-
 class StackValidationError(ZenMLBaseException):
     """Raised when a stack configuration is not valid."""
 

zenml/integrations/aws/orchestrators/sagemaker_orchestrator.py

@@ -870,9 +870,11 @@ class SagemakerOrchestrator(ContainerizedOrchestrator):
              the URL to the dashboard view in SageMaker.
         """
         try:
-            region_name, pipeline_name, execution_id = (
-                dissect_pipeline_execution_arn(execution_arn)
-            )
+            (
+                region_name,
+                pipeline_name,
+                execution_id,
+            ) = dissect_pipeline_execution_arn(execution_arn)
 
             # Get the Sagemaker session
             session = self._get_sagemaker_session()

zenml/integrations/bitbucket/plugins/event_sources/bitbucket_webhook_event_source.py

@@ -18,7 +18,6 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from zenml.enums import SecretScope
 from zenml.event_sources.base_event import (
     BaseEvent,
 )
@@ -335,9 +334,7 @@ class BitbucketWebhookEventSourceHandler(BaseWebhookEventSourceHandler):
         webhook_secret = SecretRequest(
             name=f"event_source-{str(event_source.id)}-{random_str(4)}".lower(),
             values={"webhook_secret": secret_key_value},
-            workspace=event_source.workspace.id,
-            user=event_source.user.id,
-            scope=SecretScope.WORKSPACE,
+            private=False,
         )
         secret = self.zen_store.create_secret(webhook_secret)
 

zenml/integrations/gcp/service_connectors/gcp_service_connector.py

@@ -438,7 +438,7 @@ class GCPUserAccountConfig(GCPBaseProjectIDConfig, GCPUserAccountCredentials):
 class GCPServiceAccountConfig(GCPBaseConfig, GCPServiceAccountCredentials):
     """GCP service account configuration."""
 
-    _project_id: Optional[str] = None
+    project_id: Optional[str] = None
 
     @property
     def gcp_project_id(self) -> str:
@@ -450,14 +450,14 @@ class GCPServiceAccountConfig(GCPBaseConfig, GCPServiceAccountCredentials):
         Returns:
             The GCP project ID.
         """
-        if self._project_id is None:
-            self._project_id = json.loads(
+        if self.project_id is None:
+            self.project_id = json.loads(
                 self.service_account_json.get_secret_value()
             )["project_id"]
             # Guaranteed by the field validator
-            assert self._project_id is not None
+            assert self.project_id is not None
 
-        return self._project_id
+        return self.project_id
 
 
 class GCPExternalAccountConfig(
@@ -798,7 +798,8 @@ connector will distribute the service account credentials JSON to clients
 instead (not recommended).
 
 A GCP project is required and the connector may only be used to access GCP
-resources in the specified project.
+resources in the specified project. If the `project_id` is not provided, the
+connector will use the one extracted from the service account key JSON.
 
 If you already have the GOOGLE_APPLICATION_CREDENTIALS environment variable
 configured to point to a service account key JSON file, it will be automatically

zenml/integrations/github/plugins/event_sources/github_webhook_event_source.py

@@ -19,7 +19,6 @@ from uuid import UUID
 
 from pydantic import BaseModel, ConfigDict, Field
 
-from zenml.enums import SecretScope
 from zenml.event_sources.base_event import (
     BaseEvent,
 )
@@ -361,9 +360,7 @@ class GithubWebhookEventSourceHandler(BaseWebhookEventSourceHandler):
         webhook_secret = SecretRequest(
             name=f"event_source-{str(event_source.id)}-{random_str(4)}".lower(),
             values={"webhook_secret": secret_key_value},
-            workspace=event_source.workspace.id,
-            user=event_source.user.id,
-            scope=SecretScope.WORKSPACE,
+            private=False,
         )
         secret = self.zen_store.create_secret(webhook_secret)
 

zenml/integrations/mlflow/steps/mlflow_registry.py

@@ -92,7 +92,7 @@ def mlflow_register_model_step(
     pipeline_name = step_context.pipeline.name
     current_run_name = step_context.pipeline_run.name
     pipeline_run_uuid = str(step_context.pipeline_run.id)
-    zenml_workspace = str(model_registry.workspace)
+    zenml_project = str(step_context.pipeline.project.name)
 
     # Get MLflow run ID either from params or from experiment tracker using
     # pipeline name and run name
@@ -144,8 +144,8 @@ def mlflow_register_model_step(
         metadata.zenml_run_name = run_name
     if metadata.zenml_pipeline_run_uuid is None:
         metadata.zenml_pipeline_run_uuid = pipeline_run_uuid
-    if metadata.zenml_workspace is None:
-        metadata.zenml_workspace = zenml_workspace
+    if metadata.zenml_project is None:
+        metadata.zenml_project = zenml_project
     if getattr(metadata, "mlflow_run_id", None) is None:
         setattr(metadata, "mlflow_run_id", mlflow_run_id)
 

zenml/integrations/seldon/model_deployers/seldon_model_deployer.py

@@ -245,7 +245,7 @@ class SeldonModelDeployer(BaseModelDeployer):
             )
 
             try:
-                zenml_secret = Client().get_secret_by_name_and_scope(
+                zenml_secret = Client().get_secret_by_name_and_private_status(
                     name=self.config.secret,
                 )
             except KeyError as e:

zenml/integrations/wandb/__init__.py

@@ -30,7 +30,7 @@ class WandbIntegration(Integration):
     """Definition of Plotly integration for ZenML."""
 
     NAME = WANDB
-    REQUIREMENTS = ["wandb>=0.12.12", "Pillow>=9.1.0"]
+    REQUIREMENTS = ["wandb>=0.12.12,<1.0.0", "Pillow>=9.1.0", "weave>=0.51.33,<1.0.0"]
     REQUIREMENTS_IGNORED_ON_UNINSTALL = ["Pillow"]
 
     @classmethod

zenml/integrations/wandb/experiment_trackers/wandb_experiment_tracker.py

@@ -14,7 +14,7 @@
 """Implementation for the wandb experiment tracker."""
 
 import os
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Type, Union, cast
+from typing import TYPE_CHECKING, Dict, List, Optional, Type, cast
 
 import wandb
 
@@ -30,8 +30,6 @@ from zenml.logger import get_logger
 from zenml.metadata.metadata_types import Uri
 
 if TYPE_CHECKING:
-    from wandb import Settings
-
     from zenml.config.step_run_info import StepRunInfo
     from zenml.metadata.metadata_types import MetadataType
 
@@ -76,9 +74,7 @@ class WandbExperimentTracker(BaseExperimentTracker):
         wandb_run_name = (
             settings.run_name or f"{info.run_name}_{info.pipeline_step_name}"
         )
-        self._initialize_wandb(
-            run_name=wandb_run_name, tags=tags, settings=settings.settings
-        )
+        self._initialize_wandb(run_name=wandb_run_name, tags=tags, info=info)
 
     def get_step_run_metadata(
         self, info: "StepRunInfo"
@@ -131,25 +127,49 @@ class WandbExperimentTracker(BaseExperimentTracker):
 
     def _initialize_wandb(
         self,
+        info: "StepRunInfo",
         run_name: str,
         tags: List[str],
-        settings: Union["Settings", Dict[str, Any], None] = None,
     ) -> None:
         """Initializes a wandb run.
 
         Args:
+            info: Step run information.
             run_name: Name of the wandb run to create.
             tags: Tags to attach to the wandb run.
-            settings: Additional settings for the wandb run.
         """
         logger.info(
             f"Initializing wandb with entity {self.config.entity}, project "
             f"name: {self.config.project_name}, run_name: {run_name}."
         )
+        settings = cast(
+            WandbExperimentTrackerSettings, self.get_settings(info)
+        )
         wandb.init(
             entity=self.config.entity,
             project=self.config.project_name,
             name=run_name,
             tags=tags,
-            settings=settings,
+            settings=settings.settings,
         )
+
+        if settings.enable_weave:
+            import weave
+
+            if self.config.project_name:
+                logger.info("Initializing weave")
+                weave.init(project_name=self.config.project_name)
+            else:
+                logger.info(
+                    "Weave enabled but no project_name specified. "
+                    "Skipping weave initialization."
+                )
+        else:
+            import weave
+
+            if self.config.project_name:
+                logger.info("Disabling weave")
+                weave.init(
+                    project_name=self.config.project_name,
+                    settings={"disabled": True},
+                )

zenml/integrations/wandb/flavors/wandb_experiment_tracker_flavor.py

@@ -23,7 +23,7 @@ from typing import (
     cast,
 )
 
-from pydantic import field_validator, BaseModel
+from pydantic import BaseModel, field_validator
 
 from zenml.config.base_settings import BaseSettings
 from zenml.experiment_trackers.base_experiment_tracker import (
@@ -46,11 +46,13 @@ class WandbExperimentTrackerSettings(BaseSettings):
         run_name: The Wandb run name.
         tags: Tags for the Wandb run.
         settings: Settings for the Wandb run.
+        enable_weave: Whether to enable Weave integration.
     """
 
     run_name: Optional[str] = None
     tags: List[str] = []
     settings: Dict[str, Any] = {}
+    enable_weave: bool = False
 
     @field_validator("settings", mode="before")
     @classmethod
@@ -69,8 +71,8 @@ class WandbExperimentTrackerSettings(BaseSettings):
         import wandb
 
         if isinstance(value, wandb.Settings):
-            # Depending on the wandb version, either `model_dump`, 
-            # `make_static` or `to_dict` is available to convert the settings 
+            # Depending on the wandb version, either `model_dump`,
+            # `make_static` or `to_dict` is available to convert the settings
             # to a dictionary
             if isinstance(value, BaseModel):
                 return value.model_dump()

zenml/model/model.py

@@ -532,9 +532,11 @@ class Model(BaseModel):
             )
             model = mv.model
         else:
+            # TODO: This whole thing needs to be refactored as a get_or_create
+            # REST API call.
             try:
-                model = zenml_client.zen_store.get_model(
-                    model_name_or_id=self.name
+                model = zenml_client.get_model(
+                    model_name_or_id=self.name, bypass_lazy_loader=True
                 )
             except KeyError:
                 model_request = ModelRequest(
@@ -546,8 +548,7 @@ class Model(BaseModel):
                     limitations=self.limitations,
                     trade_offs=self.trade_offs,
                     ethics=self.ethics,
-                    user=zenml_client.active_user.id,
-                    workspace=zenml_client.active_workspace.id,
+                    project=zenml_client.active_project.id,
                     save_models_to_registry=self.save_models_to_registry,
                 )
                 model_request = ModelRequest.model_validate(model_request)
@@ -559,8 +560,8 @@ class Model(BaseModel):
                         f"New model `{self.name}` was created implicitly."
                     )
                 except EntityExistsError:
-                    model = zenml_client.zen_store.get_model(
-                        model_name_or_id=self.name
+                    model = zenml_client.get_model(
+                        model_name_or_id=self.name, bypass_lazy_loader=True
                     )
 
         self._model_id = model.id
@@ -686,7 +687,7 @@ class Model(BaseModel):
                     "model version in given stage exists. It might be missing, if "
                     "the pipeline promoting model version to this stage failed,"
                     " as an example. You can explore model versions using "
-                    f"`zenml model version list -n {self.name}` CLI command."
+                    f"`zenml model version list {self.name}` CLI command."
                 )
             if str(self.version).isnumeric():
                 raise RuntimeError(
@@ -696,13 +697,12 @@ class Model(BaseModel):
                     "model version with given number exists. It might be missing, if "
                     "the pipeline creating model version failed,"
                     " as an example. You can explore model versions using "
-                    f"`zenml model version list -n {self.name}` CLI command."
+                    f"`zenml model version list {self.name}` CLI command."
                 )
 
             client = Client()
             model_version_request = ModelVersionRequest(
-                user=client.active_user.id,
-                workspace=client.active_workspace.id,
+                project=client.active_project.id,
                 name=str(self.version) if self.version else None,
                 description=self.description,
                 model=model.id,

zenml/model_registries/base_model_registry.py

@@ -68,7 +68,7 @@ class ModelRegistryModelMetadata(BaseModel):
     zenml_pipeline_uuid: Optional[str] = None
     zenml_pipeline_run_uuid: Optional[str] = None
     zenml_step_name: Optional[str] = None
-    zenml_workspace: Optional[str] = None
+    zenml_project: Optional[str] = None
 
     @property
     def custom_attributes(self) -> Dict[str, str]: