zenml-nightly 0.75.0.dev20250313__py3-none-any.whl → 0.75.0.dev20250315__py3-none-any.whl

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/gcp/vertex_custom_job_parameters.py

@@ -0,0 +1,50 @@
+#  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.
+"""Vertex custom job parameter model."""
+
+from typing import Optional
+
+from pydantic import BaseModel
+
+
+class VertexCustomJobParameters(BaseModel):
+    """Settings for the Vertex custom job parameters.
+
+    Attributes:
+        accelerator_type: Defines which accelerator (GPU, TPU) is used for the
+            job. Check out out this table to see which accelerator
+            type and count are compatible with your chosen machine type:
+            https://cloud.google.com/vertex-ai/docs/training/configure-compute#gpu-compatibility-table.
+        accelerator_count: Defines number of accelerators to be used for the
+            job. Check out out this table to see which accelerator
+            type and count are compatible with your chosen machine type:
+            https://cloud.google.com/vertex-ai/docs/training/configure-compute#gpu-compatibility-table.
+        machine_type: Machine type specified here
+            https://cloud.google.com/vertex-ai/docs/training/configure-compute#machine-types.
+        boot_disk_size_gb: Size of the boot disk in GB. (Default: 100)
+            https://cloud.google.com/vertex-ai/docs/training/configure-compute#boot_disk_options
+        boot_disk_type: Type of the boot disk. (Default: pd-ssd)
+            https://cloud.google.com/vertex-ai/docs/training/configure-compute#boot_disk_options
+        persistent_resource_id: The ID of the persistent resource to use for the job.
+            https://cloud.google.com/vertex-ai/docs/training/persistent-resource-overview
+        service_account: Specifies the service account to be used.
+    """
+
+    accelerator_type: Optional[str] = None
+    accelerator_count: int = 0
+    machine_type: str = "n1-standard-4"
+    boot_disk_size_gb: int = 100
+    boot_disk_type: str = "pd-ssd"
+    persistent_resource_id: Optional[str] = None
+    service_account: Optional[str] = None

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(step_context.pipeline.workspace.name)
+    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/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

@@ -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

zenml/login/credentials.py

@@ -21,7 +21,7 @@ from uuid import UUID
 from pydantic import BaseModel, ConfigDict
 
 from zenml.login.pro.constants import ZENML_PRO_API_URL, ZENML_PRO_URL
-from zenml.login.pro.tenant.models import TenantRead, TenantStatus
+from zenml.login.pro.workspace.models import WorkspaceRead, WorkspaceStatus
 from zenml.models import ServerModel
 from zenml.models.v2.misc.server_models import ServerDeploymentType
 from zenml.services.service_status import ServiceState
@@ -99,8 +99,8 @@ class ServerCredentials(BaseModel):
     # Pro server attributes
     organization_name: Optional[str] = None
     organization_id: Optional[UUID] = None
-    tenant_name: Optional[str] = None
-    tenant_id: Optional[UUID] = None
+    workspace_name: Optional[str] = None
+    workspace_id: Optional[UUID] = None
     pro_api_url: Optional[str] = None
     pro_dashboard_url: Optional[str] = None
 
@@ -128,7 +128,7 @@ class ServerCredentials(BaseModel):
             return ServerType.PRO_API
         if self.url == self.pro_api_url:
             return ServerType.PRO_API
-        if self.organization_id or self.tenant_id:
+        if self.organization_id or self.workspace_id:
             return ServerType.PRO
         if urlparse(self.url).hostname in [
             "localhost",
@@ -139,9 +139,9 @@ class ServerCredentials(BaseModel):
         return ServerType.REMOTE
 
     def update_server_info(
-        self, server_info: Union[ServerModel, TenantRead]
+        self, server_info: Union[ServerModel, WorkspaceRead]
     ) -> None:
-        """Update with server information received from the server itself or from a ZenML Pro tenant descriptor.
+        """Update with server information received from the server itself or from a ZenML Pro workspace descriptor.
 
         Args:
             server_info: The server information to update with.
@@ -152,20 +152,20 @@ class ServerCredentials(BaseModel):
             # All other attributes can change during the lifetime of the server
             self.deployment_type = server_info.deployment_type
             server_name = (
-                server_info.pro_tenant_name
-                or server_info.metadata.get("tenant_name")
+                server_info.pro_workspace_name
+                or server_info.metadata.get("workspace_name")
                 or server_info.name
             )
             if server_name:
                 self.server_name = server_name
             if server_info.pro_organization_id:
                 self.organization_id = server_info.pro_organization_id
-            if server_info.pro_tenant_id:
-                self.server_id = server_info.pro_tenant_id
+            if server_info.pro_workspace_id:
+                self.server_id = server_info.pro_workspace_id
             if server_info.pro_organization_name:
                 self.organization_name = server_info.pro_organization_name
-            if server_info.pro_tenant_name:
-                self.tenant_name = server_info.pro_tenant_name
+            if server_info.pro_workspace_name:
+                self.workspace_name = server_info.pro_workspace_name
             if server_info.pro_api_url:
                 self.pro_api_url = server_info.pro_api_url
             if server_info.pro_dashboard_url:
@@ -180,8 +180,8 @@ class ServerCredentials(BaseModel):
             self.server_name = server_info.name
             self.organization_name = server_info.organization_name
             self.organization_id = server_info.organization_id
-            self.tenant_name = server_info.name
-            self.tenant_id = server_info.id
+            self.workspace_name = server_info.name
+            self.workspace_id = server_info.id
             self.status = server_info.status
             self.version = server_info.version
 
@@ -192,7 +192,7 @@ class ServerCredentials(BaseModel):
         Returns:
             True if the server is available, False otherwise.
         """
-        if self.status not in [TenantStatus.AVAILABLE, ServiceState.ACTIVE]:
+        if self.status not in [WorkspaceStatus.AVAILABLE, ServiceState.ACTIVE]:
             return False
         if (
             self.api_key
@@ -270,20 +270,19 @@ class ServerCredentials(BaseModel):
         Returns:
             The URL to the ZenML dashboard for this server.
         """
-        if self.organization_id and self.server_id:
+        if self.pro_dashboard_url and self.workspace_name:
             return (
-                (self.pro_dashboard_url or ZENML_PRO_URL)
-                + f"/organizations/{str(self.organization_id)}/tenants/{str(self.server_id)}"
-            )
+                self.pro_dashboard_url or ZENML_PRO_URL
+            ) + f"/workspaces/{str(self.workspace_name)}"
 
         return self.url
 
     @property
     def dashboard_organization_url(self) -> str:
-        """Get the URL to the ZenML Pro dashboard for this tenant's organization.
+        """Get the URL to the ZenML Pro dashboard for this workspace's organization.
 
         Returns:
-            The URL to the ZenML Pro dashboard for this tenant's organization.
+            The URL to the ZenML Pro dashboard for this workspace's organization.
         """
         if self.organization_id:
             return (
@@ -293,19 +292,19 @@ class ServerCredentials(BaseModel):
 
     @property
     def dashboard_hyperlink(self) -> str:
-        """Get the hyperlink to the ZenML dashboard for this tenant.
+        """Get the hyperlink to the ZenML dashboard for this workspace.
 
         Returns:
-            The hyperlink to the ZenML dashboard for this tenant.
+            The hyperlink to the ZenML dashboard for this workspace.
         """
         return f"[link={self.dashboard_url}]{self.dashboard_url}[/link]"
 
     @property
     def api_hyperlink(self) -> str:
-        """Get the hyperlink to the ZenML OpenAPI dashboard for this tenant.
+        """Get the hyperlink to the ZenML OpenAPI dashboard for this workspace.
 
         Returns:
-            The hyperlink to the ZenML OpenAPI dashboard for this tenant.
+            The hyperlink to the ZenML OpenAPI dashboard for this workspace.
         """
         api_url = self.url + "/docs"
         return f"[link={api_url}]{self.url}[/link]"
@@ -360,10 +359,10 @@ class ServerCredentials(BaseModel):
 
     @property
     def organization_id_hyperlink(self) -> str:
-        """Get the hyperlink to the ZenML Pro dashboard for this tenant's organization using its ID.
+        """Get the hyperlink to the ZenML Pro dashboard for this workspace's organization using its ID.
 
         Returns:
-            The hyperlink to the ZenML Pro dashboard for this tenant's
+            The hyperlink to the ZenML Pro dashboard for this workspace's
             organization using its ID.
         """
         if self.organization_id is None:

zenml/login/credentials_store.py

@@ -25,7 +25,7 @@ from zenml.constants import (
 from zenml.io import fileio
 from zenml.logger import get_logger
 from zenml.login.credentials import APIToken, ServerCredentials, ServerType
-from zenml.login.pro.tenant.models import TenantRead
+from zenml.login.pro.workspace.models import WorkspaceRead
 from zenml.models import OAuthTokenResponse, ServerModel
 from zenml.utils import yaml_utils
 from zenml.utils.singleton import SingletonMetaClass
@@ -75,7 +75,7 @@ class CredentialsStore(metaclass=SingletonMetaClass):
 
     Alongside credentials, the Credentials Store is also used to store
     additional server information:
-        * ZenML Pro tenant information populated by the `zenml login` command
+        * ZenML Pro workspace information populated by the `zenml login` command
         * ZenML server information populated by the REST zen store by fetching
         the server's information endpoint after authenticating
 
@@ -341,7 +341,7 @@ class CredentialsStore(metaclass=SingletonMetaClass):
         self.clear_token(pro_api_url)
 
     def clear_all_pro_tokens(
-        self, pro_api_url: str
+        self, pro_api_url: Optional[str] = None
     ) -> List[ServerCredentials]:
         """Delete all tokens from the store for ZenML Pro servers connected to a given API server.
 
@@ -356,7 +356,7 @@ class CredentialsStore(metaclass=SingletonMetaClass):
             if (
                 server.type == ServerType.PRO
                 and server.pro_api_url
-                and server.pro_api_url == pro_api_url
+                and (pro_api_url is None or server.pro_api_url == pro_api_url)
             ):
                 if server.api_key:
                     continue
@@ -556,7 +556,7 @@ class CredentialsStore(metaclass=SingletonMetaClass):
     def update_server_info(
         self,
         server_url: str,
-        server_info: Union[ServerModel, TenantRead],
+        server_info: Union[ServerModel, WorkspaceRead],
     ) -> None:
         """Update the server information stored for a specific server URL.
 

zenml/login/pro/client.py

@@ -41,7 +41,7 @@ logger = get_logger(__name__)
 
 if TYPE_CHECKING:
     from zenml.login.pro.organization.client import OrganizationClient
-    from zenml.login.pro.tenant.client import TenantClient
+    from zenml.login.pro.workspace.client import WorkspaceClient
 
 # type alias for possible json payloads (the Anys are recursive Json instances)
 Json = Union[Dict[str, Any], List[Any], str, int, float, bool, None]
@@ -56,7 +56,7 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
     _url: str
     _api_token: APIToken
     _session: Optional[requests.Session] = None
-    _tenant: Optional["TenantClient"] = None
+    _workspace: Optional["WorkspaceClient"] = None
     _organization: Optional["OrganizationClient"] = None
 
     def __init__(self, url: str, api_token: Optional[APIToken] = None) -> None:
@@ -89,17 +89,17 @@ class ZenMLProClient(metaclass=SingletonMetaClass):
         self._api_token = api_token
 
     @property
-    def tenant(self) -> "TenantClient":
-        """Get the tenant client.
+    def workspace(self) -> "WorkspaceClient":
+        """Get the workspace client.
 
         Returns:
-            The tenant client.
+            The workspace client.
         """
-        if self._tenant is None:
-            from zenml.login.pro.tenant.client import TenantClient
+        if self._workspace is None:
+            from zenml.login.pro.workspace.client import WorkspaceClient
 
-            self._tenant = TenantClient(client=self)
-        return self._tenant
+            self._workspace = WorkspaceClient(client=self)
+        return self._workspace
 
     @property
     def organization(self) -> "OrganizationClient":

zenml/login/pro/utils.py

@@ -18,7 +18,7 @@ from zenml.login.credentials import ServerType
 from zenml.login.credentials_store import get_credentials_store
 from zenml.login.pro.client import ZenMLProClient
 from zenml.login.pro.constants import ZENML_PRO_API_URL
-from zenml.login.pro.tenant.models import TenantStatus
+from zenml.login.pro.workspace.models import WorkspaceStatus
 
 logger = get_logger(__name__)
 
@@ -44,13 +44,13 @@ def get_troubleshooting_instructions(url: str) -> str:
         client = ZenMLProClient(pro_api_url)
 
         try:
-            servers = client.tenant.list(url=url, member_only=False)
+            servers = client.workspace.list(url=url, member_only=False)
         except Exception as e:
-            logger.debug(f"Failed to list tenants: {e}")
+            logger.debug(f"Failed to list workspaces: {e}")
         else:
             if servers:
                 server = servers[0]
-                if server.status == TenantStatus.AVAILABLE:
+                if server.status == WorkspaceStatus.AVAILABLE:
                     return (
                         f"The '{server.name}' ZenML Pro server that the client "
                         "is connected to is currently running but you may not "
@@ -58,9 +58,9 @@ def get_troubleshooting_instructions(url: str) -> str:
                         "contact your ZenML Pro administrator for more "
                         "information or try to manage the server members "
                         "yourself if you have the necessary permissions by "
-                        f"visiting the ZenML Pro tenant page at {server.dashboard_url}."
+                        f"visiting the ZenML Pro workspace page at {server.dashboard_url}."
                     )
-                if server.status == TenantStatus.DEACTIVATED:
+                if server.status == WorkspaceStatus.DEACTIVATED:
                     return (
                         f"The '{server.name}' ZenML Pro server that the client "
                         "is connected to has been deactivated. "
@@ -69,14 +69,14 @@ def get_troubleshooting_instructions(url: str) -> str:
                         "you have the necessary permissions by visiting the "
                         f"ZenML Pro Organization page at {server.dashboard_organization_url}."
                     )
-                if server.status == TenantStatus.PENDING:
+                if server.status == WorkspaceStatus.PENDING:
                     return (
                         f"The '{server.name}' ZenML Pro server that the client "
                         "is connected to is currently undergoing maintenance "
                         "(e.g. being deployed, upgraded or re-activated). "
                         "Please try again later or contact your ZenML Pro "
                         "administrator for more information. You can also "
-                        f"visit the ZenML Pro tenant page at {server.dashboard_url}."
+                        f"visit the ZenML Pro workspace page at {server.dashboard_url}."
                     )
                 return (
                     f"The '{server.name}' ZenML Pro server that the client "

zenml/login/pro/{tenant → workspace}/__init__.py

@@ -11,4 +11,4 @@
 #  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.
-"""ZenML Pro tenant client."""
+"""ZenML Pro workspace client."""

zenml/login/pro/{tenant → workspace}/client.py

@@ -11,80 +11,80 @@
 #  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.
-"""ZenML Pro tenant client."""
+"""ZenML Pro workspace client."""
 
 from typing import List, Optional
 from uuid import UUID
 
 from zenml.logger import get_logger
 from zenml.login.pro.client import ZenMLProClient
-from zenml.login.pro.tenant.models import TenantRead, TenantStatus
+from zenml.login.pro.workspace.models import WorkspaceRead, WorkspaceStatus
 
 logger = get_logger(__name__)
 
-TENANTS_ROUTE = "/tenants"
+WORKSPACES_ROUTE = "/workspaces"
 
 
-class TenantClient:
-    """Tenant management client."""
+class WorkspaceClient:
+    """Workspace management client."""
 
     def __init__(
         self,
         client: ZenMLProClient,
     ):
-        """Initialize the tenant client.
+        """Initialize the workspace client.
 
         Args:
             client: ZenML Pro client.
         """
         self.client = client
 
-    def get(self, id: UUID) -> TenantRead:
-        """Get a tenant by id.
+    def get(self, id: UUID) -> WorkspaceRead:
+        """Get a workspace by id.
 
         Args:
-            id: Id. of the tenant to retrieve.
+            id: Id. of the workspace to retrieve.
 
         Returns:
-            A tenant.
+            A workspace.
         """
         return self.client._get_resource(
             resource_id=id,
-            route=TENANTS_ROUTE,
-            response_model=TenantRead,
+            route=WORKSPACES_ROUTE,
+            response_model=WorkspaceRead,
         )
 
     def list(
         self,
         offset: int = 0,
         limit: int = 20,
-        tenant_name: Optional[str] = None,
+        workspace_name: Optional[str] = None,
         url: Optional[str] = None,
         organization_id: Optional[UUID] = None,
-        status: Optional[TenantStatus] = None,
+        status: Optional[WorkspaceStatus] = None,
         member_only: bool = False,
-    ) -> List[TenantRead]:
-        """List tenants.
+    ) -> List[WorkspaceRead]:
+        """List workspaces.
 
         Args:
             offset: Offset to use for filtering.
             limit: Limit used for filtering.
-            tenant_name: Tenant name to filter by.
-            url: Tenant service URL to filter by.
+            workspace_name: Workspace name to filter by.
+            url: Workspace service URL to filter by.
             organization_id: Organization ID to filter by.
-            status: Filter for only tenants with this status.
-            member_only: If True, only list tenants where the user is a member
-                (i.e. users that can connect to the tenant).
+            status: Filter for only workspaces with this status.
+            member_only: If True, only list workspaces where the user is a member
+                (i.e. users that can connect to the workspace).
 
         Returns:
-            List of tenants.
+            List of workspaces.
         """
         return self.client._list_resources(
-            route=TENANTS_ROUTE,
-            response_model=TenantRead,
+            route=WORKSPACES_ROUTE,
+            response_model=WorkspaceRead,
             offset=offset,
             limit=limit,
-            tenant_name=tenant_name,
+            workspace_name=workspace_name,
             url=url,
             organization_id=organization_id,
             status=status,