zenml-nightly 0.66.0.dev20240928__py3-none-any.whl → 0.68.1.dev20241102__py3-none-any.whl

zenml/cli/utils.py

@@ -57,8 +57,6 @@ from zenml.console import console, zenml_style_defaults
 from zenml.constants import (
     FILTERING_DATETIME_FORMAT,
     IS_DEBUG_ENV,
-    NOT_INSTALLED_MESSAGE,
-    TERRAFORM_NOT_INSTALLED_MESSAGE,
 )
 from zenml.enums import GenericFilterOps, StackComponentType
 from zenml.logger import get_logger
@@ -81,7 +79,6 @@ from zenml.services import BaseService, ServiceState
 from zenml.stack import StackComponent
 from zenml.stack.stack_component import StackComponentConfig
 from zenml.utils import secret_utils
-from zenml.zen_server.deploy import ServerDeployment
 
 if TYPE_CHECKING:
     from uuid import UUID
@@ -225,6 +222,8 @@ def print_table(
         caption: Caption of the table.
         columns: Optional column configurations to be used in the table.
     """
+    from rich.text import Text
+
     column_keys = {key: None for dict_ in obj for key in dict_}
     column_names = [columns.get(key, key.upper()) for key in column_keys]
     rich_table = table.Table(
@@ -243,10 +242,19 @@ def print_table(
             if key is None:
                 values.append(None)
             else:
-                value = str(dict_.get(key) or " ")
-                # escape text when square brackets are used
-                if "[" in value:
-                    value = escape(value)
+                v = dict_.get(key) or " "
+                if isinstance(v, str) and (
+                    v.startswith("http://") or v.startswith("https://")
+                ):
+                    # Display the URL as a hyperlink in a way that doesn't break
+                    # the URL when it needs to be wrapped over multiple lines
+                    value: Union[str, Text] = Text(v, style=f"link {v}")
+                else:
+                    value = str(v)
+                    # Escape text when square brackets are used, but allow
+                    # links to be decorated as rich style links
+                    if "[" in value and "[link=" not in value:
+                        value = escape(value)
                 values.append(value)
         rich_table.add_row(*values)
     if len(rich_table.columns) > 1:
@@ -260,6 +268,7 @@ def print_pydantic_models(
     exclude_columns: Optional[List[str]] = None,
     active_models: Optional[List[T]] = None,
     show_active: bool = False,
+    rename_columns: Dict[str, str] = {},
 ) -> None:
     """Prints the list of Pydantic models in a table.
 
@@ -272,6 +281,7 @@ def print_pydantic_models(
         active_models: Optional list of active models of the given type T.
         show_active: Flag to decide whether to append the active model on the
             top of the list.
+        rename_columns: Optional dictionary to rename columns.
     """
     if exclude_columns is None:
         exclude_columns = list()
@@ -328,6 +338,8 @@ def print_pydantic_models(
 
         for k in include_columns:
             value = getattr(model, k)
+            if k in rename_columns:
+                k = rename_columns[k]
             # In case the response model contains nested `BaseResponse`s
             #  we want to attempt to represent them by name, if they contain
             #  such a field, else the id is used
@@ -352,6 +364,7 @@ def print_pydantic_models(
                 items[k] = [str(v) for v in value]
             else:
                 items[k] = str(value)
+
         # prepend an active marker if a function to mark active was passed
         if not active_models and not show_active:
             return items
@@ -523,43 +536,6 @@ def format_integration_list(
     return list_of_dicts
 
 
-def print_stack_outputs(stack: "StackResponse") -> None:
-    """Prints outputs for stacks deployed with mlstacks.
-
-    Args:
-        stack: Instance of a stack model.
-    """
-    verify_mlstacks_prerequisites_installation()
-
-    if not stack.stack_spec_path:
-        declare("No stack spec path is set for this stack.")
-        return
-    stack_caption = f"'{stack.name}' stack"
-    rich_table = table.Table(
-        box=box.HEAVY_EDGE,
-        title="MLStacks Outputs",
-        caption=stack_caption,
-        show_lines=True,
-    )
-    rich_table.add_column("OUTPUT_KEY", overflow="fold")
-    rich_table.add_column("OUTPUT_VALUE", overflow="fold")
-
-    from mlstacks.utils.terraform_utils import get_stack_outputs
-
-    stack_spec_file = stack.stack_spec_path
-    stack_outputs = get_stack_outputs(stack_path=stack_spec_file)
-
-    for output_key, output_value in stack_outputs.items():
-        rich_table.add_row(output_key, output_value)
-
-    # capitalize entries in first column
-    rich_table.columns[0]._cells = [
-        component.upper()  # type: ignore[union-attr]
-        for component in rich_table.columns[0]._cells
-    ]
-    console.print(rich_table)
-
-
 def print_stack_configuration(stack: "StackResponse", active: bool) -> None:
     """Prints the configuration options of a stack.
 
@@ -609,9 +585,6 @@ def print_stack_configuration(stack: "StackResponse", active: bool) -> None:
         f"{f'owned by user {stack.user.name}.' if stack.user else 'unowned.'}"
     )
 
-    if stack.stack_spec_path:
-        declare(f"Stack spec path for `mlstacks`: '{stack.stack_spec_path}'")
-
 
 def print_flavor_list(flavors: Page["FlavorResponse"]) -> None:
     """Prints the list of flavors.
@@ -655,7 +628,7 @@ def print_stack_component_configuration(
 
     declare(
         f"{component.type.value.title()} '{component.name}' of flavor "
-        f"'{component.flavor}' with id '{component.id}' is owned by "
+        f"'{component.flavor_name}' with id '{component.id}' is owned by "
         f"user '{user_name}'."
     )
 
@@ -1433,74 +1406,6 @@ def print_served_model_configuration(
     console.print(rich_table)
 
 
-def print_server_deployment_list(servers: List["ServerDeployment"]) -> None:
-    """Print a table with a list of ZenML server deployments.
-
-    Args:
-        servers: list of ZenML server deployments
-    """
-    server_dicts = []
-    for server in servers:
-        status = ""
-        url = ""
-        connected = ""
-        if server.status:
-            status = get_service_state_emoji(server.status.status)
-            if server.status.url:
-                url = server.status.url
-            if server.status.connected:
-                connected = ":point_left:"
-        server_dicts.append(
-            {
-                "STATUS": status,
-                "NAME": server.config.name,
-                "PROVIDER": server.config.provider.value,
-                "URL": url,
-                "CONNECTED": connected,
-            }
-        )
-    print_table(server_dicts)
-
-
-def print_server_deployment(server: "ServerDeployment") -> None:
-    """Prints the configuration and status of a ZenML server deployment.
-
-    Args:
-        server: Server deployment to print
-    """
-    server_name = server.config.name
-    title_ = f"ZenML server '{server_name}'"
-
-    rich_table = table.Table(
-        box=box.HEAVY_EDGE,
-        title=title_,
-        show_header=False,
-        show_lines=True,
-    )
-    rich_table.add_column("", overflow="fold")
-    rich_table.add_column("", overflow="fold")
-
-    server_info = []
-
-    if server.status:
-        server_info.extend(
-            [
-                ("URL", server.status.url or ""),
-                ("STATUS", get_service_state_emoji(server.status.status)),
-                ("STATUS_MESSAGE", server.status.status_message or ""),
-                (
-                    "CONNECTED",
-                    ":white_check_mark:" if server.status.connected else "",
-                ),
-            ]
-        )
-
-    for item in server_info:
-        rich_table.add_row(*item)
-
-    console.print(rich_table)
-
-
 def describe_pydantic_object(schema_json: Dict[str, Any]) -> None:
     """Describes a Pydantic object based on the dict-representation of its schema.
 
@@ -1674,7 +1579,7 @@ def print_components_table(
             "ACTIVE": ":point_right:" if is_active else "",
             "NAME": component.name,
             "COMPONENT ID": component.id,
-            "FLAVOR": component.flavor,
+            "FLAVOR": component.flavor_name,
             "OWNER": f"{component.user.name if component.user else '-'}",
         }
         configurations.append(component_config)
@@ -2761,32 +2666,9 @@ def print_model_url(url: Optional[str]) -> None:
         warning(
             "You can display various ZenML entities including pipelines, "
             "runs, stacks and much more on the ZenML Dashboard. "
-            "You can try it locally, by running `zenml up`, or remotely, "
-            "by deploying ZenML on the infrastructure of your choice."
-        )
-
-
-def warn_deprecated_example_subcommand() -> None:
-    """Warning for deprecating example subcommand."""
-    warning(
-        "The `example` CLI subcommand has been deprecated and will be removed "
-        "in a future release."
-    )
-
-
-def verify_mlstacks_prerequisites_installation() -> None:
-    """Checks if the `mlstacks` package is installed."""
-    try:
-        import mlstacks  # noqa: F401
-        import python_terraform  # noqa: F401
-
-        subprocess.check_output(
-            ["terraform", "--version"], universal_newlines=True
+            "You can try it locally, by running `zenml local --local`, or "
+            "remotely, by deploying ZenML on the infrastructure of your choice."
         )
-    except ImportError:
-        error(NOT_INSTALLED_MESSAGE)
-    except subprocess.CalledProcessError:
-        error(TERRAFORM_NOT_INSTALLED_MESSAGE)
 
 
 def is_jupyter_installed() -> bool:

zenml/client.py

@@ -346,6 +346,8 @@ class Client(metaclass=ClientMetaClass):
     """
 
     _active_user: Optional["UserResponse"] = None
+    _active_workspace: Optional["WorkspaceResponse"] = None
+    _active_stack: Optional["StackResponse"] = None
 
     def __init__(
         self,
@@ -1113,9 +1115,13 @@ class Client(metaclass=ClientMetaClass):
         Raises:
             RuntimeError: If the active workspace is not set.
         """
-        if ENV_ZENML_ACTIVE_WORKSPACE_ID in os.environ:
-            workspace_id = os.environ[ENV_ZENML_ACTIVE_WORKSPACE_ID]
-            return self.get_workspace(workspace_id)
+        if workspace_id := os.environ.get(ENV_ZENML_ACTIVE_WORKSPACE_ID):
+            if not self._active_workspace or self._active_workspace.id != UUID(
+                workspace_id
+            ):
+                self._active_workspace = self.get_workspace(workspace_id)
+
+            return self._active_workspace
 
         from zenml.constants import DEFAULT_WORKSPACE_NAME
 
@@ -1465,8 +1471,13 @@ class Client(metaclass=ClientMetaClass):
         Raises:
             RuntimeError: If the active stack is not set.
         """
-        if ENV_ZENML_ACTIVE_STACK_ID in os.environ:
-            return self.get_stack(os.environ[ENV_ZENML_ACTIVE_STACK_ID])
+        if env_stack_id := os.environ.get(ENV_ZENML_ACTIVE_STACK_ID):
+            if not self._active_stack or self._active_stack.id != UUID(
+                env_stack_id
+            ):
+                self._active_stack = self.get_stack(env_stack_id)
+
+            return self._active_stack
 
         stack_id: Optional[UUID] = None
 
@@ -1534,6 +1545,8 @@ class Client(metaclass=ClientMetaClass):
         remote_components: List[str] = []
         assert stack.components is not None
         for component_type, components in stack.components.items():
+            component_flavor: Union[FlavorResponse, str]
+
             for component in components:
                 if isinstance(component, UUID):
                     component_response = self.get_stack_component(
@@ -1554,7 +1567,7 @@ class Client(metaclass=ClientMetaClass):
 
                 configuration = validate_stack_component_config(
                     configuration_dict=component_config,
-                    flavor_name=component_flavor,
+                    flavor=component_flavor,
                     component_type=component_type,
                     # Always enforce validation of custom flavors
                     validate_custom_flavors=True,
@@ -1563,13 +1576,18 @@ class Client(metaclass=ClientMetaClass):
                 # `validate_custom_flavors=True` above
                 assert configuration is not None
                 warn_if_config_server_mismatch(configuration)
+                flavor_name = (
+                    component_flavor.name
+                    if isinstance(component_flavor, FlavorResponse)
+                    else component_flavor
+                )
                 if configuration.is_local:
                     local_components.append(
-                        f"{component_type.value}: {component_flavor}"
+                        f"{component_type.value}: {flavor_name}"
                     )
                 elif configuration.is_remote:
                     remote_components.append(
-                        f"{component_type.value}: {component_flavor}"
+                        f"{component_type.value}: {flavor_name}"
                     )
 
         if local_components and remote_components:
@@ -1906,6 +1924,7 @@ class Client(metaclass=ClientMetaClass):
         user_id: Optional[Union[str, UUID]] = None,
         connector_id: Optional[Union[str, UUID]] = None,
         stack_id: Optional[Union[str, UUID]] = None,
+        user: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[ComponentResponse]:
         """Lists all registered stack components.
@@ -1925,6 +1944,7 @@ class Client(metaclass=ClientMetaClass):
             connector_id: The id of the connector to filter by.
             stack_id: The id of the stack to filter by.
             name: The name of the component to filter by.
+            user: The ID of name of the user to filter by.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -1946,6 +1966,7 @@ class Client(metaclass=ClientMetaClass):
             id=id,
             created=created,
             updated=updated,
+            user=user,
         )
         component_filter_model.set_scope_workspace(self.active_workspace.id)
 
@@ -1982,7 +2003,7 @@ class Client(metaclass=ClientMetaClass):
 
         validated_config = validate_stack_component_config(
             configuration_dict=configuration,
-            flavor_name=flavor,
+            flavor=flavor,
             component_type=component_type,
             # Always enforce validation of custom flavors
             validate_custom_flavors=True,
@@ -2083,7 +2104,7 @@ class Client(metaclass=ClientMetaClass):
 
             validated_config = validate_stack_component_config(
                 configuration_dict=existing_configuration,
-                flavor_name=component.flavor,
+                flavor=component.flavor,
                 component_type=component.type,
                 # Always enforce validation of custom flavors
                 validate_custom_flavors=True,
@@ -2494,7 +2515,7 @@ class Client(metaclass=ClientMetaClass):
         Returns:
             Model of the pipeline run.
         """
-        from zenml.new.pipelines.run_utils import (
+        from zenml.pipelines.run_utils import (
             validate_run_config_is_runnable_from_server,
             validate_stack_is_runnable_from_server,
             wait_for_pipeline_run_to_finish,
@@ -3778,6 +3799,7 @@ class Client(metaclass=ClientMetaClass):
         code_repository: Optional[Union[UUID, str]] = None,
         model: Optional[Union[UUID, str]] = None,
         stack: Optional[Union[UUID, str]] = None,
+        stack_component: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[PipelineRunResponse]:
         """List all pipeline runs.
@@ -3816,6 +3838,7 @@ class Client(metaclass=ClientMetaClass):
             code_repository: Filter by code repository name/ID.
             model: Filter by model name/ID.
             stack: Filter by stack name/ID.
+            stack_component: Filter by stack component name/ID.
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -3854,6 +3877,7 @@ class Client(metaclass=ClientMetaClass):
             code_repository=code_repository,
             stack=stack,
             model=model,
+            stack_component=stack_component,
             templatable=templatable,
         )
         runs_filter_model.set_scope_workspace(self.active_workspace.id)
@@ -3862,21 +3886,6 @@ class Client(metaclass=ClientMetaClass):
             hydrate=hydrate,
         )
 
-    def list_runs(self, **kwargs: Any) -> Page[PipelineRunResponse]:
-        """(Deprecated) List all pipeline runs.
-
-        Args:
-            **kwargs: The filter arguments passed to `list_pipeline_runs`.
-
-        Returns:
-            A page with Pipeline Runs fitting the filter description
-        """
-        logger.warning(
-            "`Client.list_runs()` is deprecated and will be removed in a "
-            "future release. Please use `Client.list_pipeline_runs()` instead."
-        )
-        return self.list_pipeline_runs(**kwargs)
-
     def delete_pipeline_run(
         self,
         name_id_or_prefix: Union[str, UUID],
@@ -3923,18 +3932,18 @@ class Client(metaclass=ClientMetaClass):
         created: Optional[Union[datetime, str]] = None,
         updated: Optional[Union[datetime, str]] = None,
         name: Optional[str] = None,
-        entrypoint_name: Optional[str] = None,
-        code_hash: Optional[str] = None,
         cache_key: Optional[str] = None,
+        code_hash: Optional[str] = None,
         status: Optional[str] = None,
         start_time: Optional[Union[datetime, str]] = None,
         end_time: Optional[Union[datetime, str]] = None,
         pipeline_run_id: Optional[Union[str, UUID]] = None,
+        deployment_id: Optional[Union[str, UUID]] = None,
         original_step_run_id: Optional[Union[str, UUID]] = None,
         workspace_id: Optional[Union[str, UUID]] = None,
         user_id: Optional[Union[str, UUID]] = None,
         model_version_id: Optional[Union[str, UUID]] = None,
-        num_outputs: Optional[Union[int, str]] = None,
+        model: Optional[Union[UUID, str]] = None,
         hydrate: bool = False,
     ) -> Page[StepRunResponse]:
         """List all pipelines.
@@ -3951,15 +3960,15 @@ class Client(metaclass=ClientMetaClass):
             end_time: Use to filter by the time when the step finished running
             workspace_id: The id of the workspace to filter by.
             user_id: The  id of the user to filter by.
-            pipeline_run_id: The  id of the pipeline run to filter by.
-            original_step_run_id: The  id of the pipeline run to filter by.
+            pipeline_run_id: The id of the pipeline run to filter by.
+            deployment_id: The id of the deployment to filter by.
+            original_step_run_id: The id of the original step run to filter by.
             model_version_id: The ID of the model version to filter by.
-            name: The name of the run to filter by.
-            entrypoint_name: The entrypoint_name of the run to filter by.
-            code_hash: The code_hash of the run to filter by.
-            cache_key: The cache_key of the run to filter by.
+            model: Filter by model name/ID.
+            name: The name of the step run to filter by.
+            cache_key: The cache key of the step run to filter by.
+            code_hash: The code hash of the step run to filter by.
             status: The name of the run to filter by.
-            num_outputs: The number of outputs for the step run
             hydrate: Flag deciding whether to hydrate the output model(s)
                 by including metadata fields in the response.
 
@@ -3972,10 +3981,10 @@ class Client(metaclass=ClientMetaClass):
             size=size,
             logical_operator=logical_operator,
             id=id,
-            entrypoint_name=entrypoint_name,
-            code_hash=code_hash,
             cache_key=cache_key,
+            code_hash=code_hash,
             pipeline_run_id=pipeline_run_id,
+            deployment_id=deployment_id,
             original_step_run_id=original_step_run_id,
             status=status,
             created=created,
@@ -3986,7 +3995,7 @@ class Client(metaclass=ClientMetaClass):
             workspace_id=workspace_id,
             user_id=user_id,
             model_version_id=model_version_id,
-            num_outputs=num_outputs,
+            model=model,
         )
         step_run_filter_model.set_scope_workspace(self.active_workspace.id)
         return self.zen_store.list_run_steps(
@@ -7258,6 +7267,7 @@ class Client(metaclass=ClientMetaClass):
             NotImplementedError: If the client is not connected to a ZenML
                 server.
         """
+        from zenml.login.credentials_store import get_credentials_store
         from zenml.zen_stores.rest_zen_store import RestZenStore
 
         zen_store = self.zen_store
@@ -7266,8 +7276,15 @@ class Client(metaclass=ClientMetaClass):
                 "API key configuration is only supported if connected to a "
                 "ZenML server."
             )
+
+        credentials_store = get_credentials_store()
         assert isinstance(zen_store, RestZenStore)
-        zen_store.set_api_key(api_key=key)
+
+        credentials_store.set_api_key(server_url=zen_store.url, api_key=key)
+
+        # Force a re-authentication to start using the new API key
+        # right away.
+        zen_store.authenticate(force=True)
 
     def list_api_keys(
         self,

zenml/client_lazy_loader.py

@@ -16,17 +16,21 @@
 import contextlib
 from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Type
 
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+
+from zenml.logger import get_logger
 
 if TYPE_CHECKING:
     from zenml.client import Client
 
+logger = get_logger(__name__)
+
 
 class _CallStep(BaseModel):
     attribute_name: Optional[str] = None
-    is_call: Optional[bool] = False
-    call_args: Optional[List[Any]] = []
-    call_kwargs: Optional[Dict[str, Any]] = {}
+    is_call: bool = False
+    call_args: List[Any] = Field(default_factory=list)
+    call_kwargs: Dict[str, Any] = Field(default_factory=dict)
     selector: Optional[Any] = None
 
 
@@ -112,11 +116,20 @@ class ClientLazyLoader(BaseModel):
                         "Invalid call chain. Reach out to the ZenML team."
                     )
             except Exception as e:
-                raise RuntimeError(
+                logger.debug(
                     f"Failed to evaluate lazy load chain `{self.method_name}` "
-                    f"+ `{self.call_chain}`. Reach out to the ZenML team via "
-                    "Slack or GitHub to check further."
-                ) from e
+                    f"+ `{next_step}` + `{self.call_chain}`."
+                )
+                msg = f"`{self.method_name}("
+                if next_step:
+                    for arg in next_step.call_args:
+                        msg += f"'{arg}',"
+                    for k, v in next_step.call_kwargs.items():
+                        msg += f"{k}='{v}',"
+                    msg = msg[:-1]
+                msg += f")` failed during lazy load with error: {e}"
+                logger.error(msg)
+                raise RuntimeError(msg)
             return self_
 
         self_ = getattr(Client(), self.method_name)
@@ -172,10 +185,10 @@ def evaluate_all_lazy_load_args_in_client_methods(
     """
     import inspect
 
-    def _evaluate_args(func: Callable[..., Any]) -> Any:
+    def _evaluate_args(
+        func: Callable[..., Any], is_instance_method: bool
+    ) -> Any:
         def _inner(*args: Any, **kwargs: Any) -> Any:
-            is_instance_method = "self" in inspect.getfullargspec(func).args
-
             args_ = list(args)
             if not is_instance_method:
                 from zenml.client import Client
@@ -201,7 +214,11 @@ def evaluate_all_lazy_load_args_in_client_methods(
 
     def _decorate() -> Type["Client"]:
         for name, fn in inspect.getmembers(cls, inspect.isfunction):
-            setattr(cls, name, _evaluate_args(fn))
+            setattr(
+                cls,
+                name,
+                _evaluate_args(fn, "self" in inspect.getfullargspec(fn).args),
+            )
         return cls
 
     return _decorate()

zenml/config/compiler.py

@@ -39,12 +39,12 @@ from zenml.config.step_configurations import (
 from zenml.environment import get_run_environment_dict
 from zenml.exceptions import StackValidationError
 from zenml.models import PipelineDeploymentBase
-from zenml.new.pipelines.run_utils import get_default_run_name
+from zenml.pipelines.run_utils import get_default_run_name
 from zenml.utils import pydantic_utils, settings_utils
 
 if TYPE_CHECKING:
     from zenml.config.source import Source
-    from zenml.new.pipelines.pipeline import Pipeline
+    from zenml.pipelines.pipeline_definition import Pipeline
     from zenml.stack import Stack, StackComponent
     from zenml.steps.step_invocation import StepInvocation
 
@@ -208,6 +208,7 @@ class Compiler:
                 enable_artifact_visualization=config.enable_artifact_visualization,
                 enable_step_logs=config.enable_step_logs,
                 settings=config.settings,
+                tags=config.tags,
                 extra=config.extra,
                 model=config.model,
                 parameters=config.parameters,
@@ -583,8 +584,6 @@ class Compiler:
         Raises:
             ValueError: If the pipeline has no steps.
         """
-        from zenml.pipelines import BasePipeline
-
         if not step_specs:
             raise ValueError(
                 f"Pipeline '{pipeline.name}' cannot be compiled because it has "
@@ -594,13 +593,10 @@ class Compiler:
                 "https://docs.zenml.io/user-guide/starter-guide."
             )
 
-        additional_spec_args: Dict[str, Any] = {}
-        if isinstance(pipeline, BasePipeline):
-            # use older spec version for legacy pipelines
-            additional_spec_args["version"] = "0.3"
-        else:
-            additional_spec_args["source"] = pipeline.resolve()
-            additional_spec_args["parameters"] = pipeline._parameters
+        additional_spec_args: Dict[str, Any] = {
+            "source": pipeline.resolve(),
+            "parameters": pipeline._parameters,
+        }
 
         return PipelineSpec(steps=step_specs, **additional_spec_args)
 

zenml/config/global_config.py

@@ -689,6 +689,15 @@ class GlobalConfiguration(BaseModel, metaclass=GlobalConfigMetaClass):
         self._configure_store(config, skip_default_registrations, **kwargs)
         logger.info("Updated the global store configuration.")
 
+    @property
+    def is_initialized(self) -> bool:
+        """Check if the global configuration is initialized.
+
+        Returns:
+            `True` if the global configuration is initialized.
+        """
+        return self._zen_store is not None
+
     @property
     def zen_store(self) -> "BaseZenStore":
         """Initialize and/or return the global zen store.

zenml/config/pipeline_configurations.py

@@ -13,7 +13,7 @@
 #  permissions and limitations under the License.
 """Pipeline configuration classes."""
 
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
 from pydantic import SerializeAsAny, field_validator
 
@@ -39,6 +39,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
     extra: Dict[str, Any] = {}
     failure_hook_source: Optional[SourceWithValidator] = None
     success_hook_source: Optional[SourceWithValidator] = None