zenml-nightly 0.67.0.dev20241002__py3-none-any.whl → 0.68.0.dev20241027__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
@@ -523,43 +521,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 +570,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.
@@ -2766,29 +2724,6 @@ def print_model_url(url: Optional[str]) -> None:
         )
 
 
-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
-        )
-    except ImportError:
-        error(NOT_INSTALLED_MESSAGE)
-    except subprocess.CalledProcessError:
-        error(TERRAFORM_NOT_INSTALLED_MESSAGE)
-
-
 def is_jupyter_installed() -> bool:
     """Checks if Jupyter notebook is installed.
 

zenml/client.py

@@ -2494,7 +2494,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,
@@ -3862,21 +3862,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,13 +3908,13 @@ 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,
@@ -3951,13 +3936,13 @@ 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.
+            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)
@@ -3972,10 +3957,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,

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
 
@@ -583,8 +583,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 +592,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/server_config.py

@@ -29,6 +29,7 @@ from zenml.constants import (
     DEFAULT_ZENML_SERVER_LOGIN_RATE_LIMIT_DAY,
     DEFAULT_ZENML_SERVER_LOGIN_RATE_LIMIT_MINUTE,
     DEFAULT_ZENML_SERVER_MAX_DEVICE_AUTH_ATTEMPTS,
+    DEFAULT_ZENML_SERVER_MAX_REQUEST_BODY_SIZE_IN_BYTES,
     DEFAULT_ZENML_SERVER_NAME,
     DEFAULT_ZENML_SERVER_PIPELINE_RUN_AUTH_WINDOW,
     DEFAULT_ZENML_SERVER_SECURE_HEADERS_CACHE,
@@ -40,7 +41,6 @@ from zenml.constants import (
     DEFAULT_ZENML_SERVER_SECURE_HEADERS_XFO,
     DEFAULT_ZENML_SERVER_SECURE_HEADERS_XXP,
     DEFAULT_ZENML_SERVER_THREAD_POOL_SIZE,
-    DEFAULT_ZENML_SERVER_USE_LEGACY_DASHBOARD,
     ENV_ZENML_SERVER_PREFIX,
 )
 from zenml.enums import AuthScheme
@@ -217,9 +217,6 @@ class ServerConfiguration(BaseModel):
             one of the reserved values `disabled`, `no`, `none`, `false`, `off`
             or to an empty string, the `Permissions-Policy` header will not be
             included in responses.
-        use_legacy_dashboard: Whether to use the legacy dashboard. If set to
-            `True`, the dashboard will be used with the old UI. If set to
-            `False`, the new dashboard will be used.
         server_name: The name of the ZenML server. Used only during initial
             deployment. Can be changed later as a part of the server settings.
         display_announcements: Whether to display announcements about ZenML in
@@ -231,6 +228,8 @@ class ServerConfiguration(BaseModel):
         auto_activate: Whether to automatically activate the server and create a
             default admin user account with an empty password during the initial
             deployment.
+        max_request_body_size_in_bytes: The maximum size of the request body in
+            bytes. If not specified, the default value of 256 Kb will be used.
     """
 
     deployment_type: ServerDeploymentType = ServerDeploymentType.OTHER
@@ -310,7 +309,6 @@ class ServerConfiguration(BaseModel):
         default=DEFAULT_ZENML_SERVER_SECURE_HEADERS_PERMISSIONS,
         union_mode="left_to_right",
     )
-    use_legacy_dashboard: bool = DEFAULT_ZENML_SERVER_USE_LEGACY_DASHBOARD
 
     server_name: str = DEFAULT_ZENML_SERVER_NAME
     display_announcements: bool = True
@@ -319,6 +317,10 @@ class ServerConfiguration(BaseModel):
 
     thread_pool_size: int = DEFAULT_ZENML_SERVER_THREAD_POOL_SIZE
 
+    max_request_body_size_in_bytes: int = (
+        DEFAULT_ZENML_SERVER_MAX_REQUEST_BODY_SIZE_IN_BYTES
+    )
+
     _deployment_id: Optional[UUID] = None
 
     @model_validator(mode="before")

zenml/config/step_configurations.py

@@ -31,6 +31,7 @@ from pydantic import (
     model_validator,
 )
 
+from zenml.artifacts.artifact_config import ArtifactConfig
 from zenml.artifacts.external_artifact_config import (
     ExternalArtifactConfiguration,
 )
@@ -59,6 +60,7 @@ class PartialArtifactConfiguration(StrictBaseModel):
     # TODO: This could be moved to the `PipelineDeployment` as it's the same
     # for all steps/outputs
     default_materializer_source: Optional[SourceWithValidator] = None
+    artifact_config: Optional[ArtifactConfig] = None
 
     @model_validator(mode="before")
     @classmethod

zenml/constants.py

@@ -181,13 +181,11 @@ ENV_ZENML_SERVER_AUTH_SCHEME = f"{ENV_ZENML_SERVER_PREFIX}AUTH_SCHEME"
 ENV_ZENML_SERVER_REPORTABLE_RESOURCES = (
     f"{ENV_ZENML_SERVER_PREFIX}REPORTABLE_RESOURCES"
 )
-ENV_ZENML_SERVER_USE_LEGACY_DASHBOARD = (
-    f"{ENV_ZENML_SERVER_PREFIX}USE_LEGACY_DASHBOARD"
-)
 ENV_ZENML_SERVER_AUTO_ACTIVATE = f"{ENV_ZENML_SERVER_PREFIX}AUTO_ACTIVATE"
 ENV_ZENML_RUN_SINGLE_STEPS_WITHOUT_STACK = (
     "ZENML_RUN_SINGLE_STEPS_WITHOUT_STACK"
 )
+ENV_ZENML_PREVENT_CLIENT_SIDE_CACHING = "ZENML_PREVENT_CLIENT_SIDE_CACHING"
 
 # Logging variables
 IS_DEBUG_ENV: bool = handle_bool_env_var(ENV_ZENML_DEBUG, default=False)
@@ -253,7 +251,7 @@ DEFAULT_SERVICE_START_STOP_TIMEOUT = 60
 DEFAULT_LOCAL_SERVICE_IP_ADDRESS = "127.0.0.1"
 ZEN_SERVER_ENTRYPOINT = "zenml.zen_server.zen_server_api:app"
 
-STEP_SOURCE_PARAMETER_NAME = "step_source"
+CODE_HASH_PARAMETER_NAME = "step_source"
 
 # Server settings
 DEFAULT_ZENML_SERVER_NAME = "default"
@@ -315,8 +313,8 @@ DEFAULT_ZENML_SERVER_SECURE_HEADERS_PERMISSIONS = (
     "payment=(), sync-xhr=(), usb=()"
 )
 DEFAULT_ZENML_SERVER_SECURE_HEADERS_REPORT_TO = "default"
-DEFAULT_ZENML_SERVER_USE_LEGACY_DASHBOARD = False
 DEFAULT_ZENML_SERVER_REPORT_USER_ACTIVITY_TO_DB_SECONDS = 30
+DEFAULT_ZENML_SERVER_MAX_REQUEST_BODY_SIZE_IN_BYTES = 256 * 1024 * 1024
 
 # Configurations to decide which resources report their usage and check for
 # entitlement in the case of a cloud deployment. Expected Format is this:
@@ -352,7 +350,6 @@ EVENT_FLAVORS = "/event-flavors"
 EVENT_SOURCES = "/event-sources"
 FLAVORS = "/flavors"
 GET_OR_CREATE = "/get-or-create"
-GRAPH = "/graph"
 HEALTH = "/health"
 INFO = "/info"
 LOGIN = "/login"
@@ -445,33 +442,6 @@ KUBERNETES_CLUSTER_RESOURCE_TYPE = "kubernetes-cluster"
 
 # Stack Recipe constants
 STACK_RECIPES_GITHUB_REPO = "https://github.com/zenml-io/mlops-stacks.git"
-ALPHA_MESSAGE = (
-    "The mlstacks tool/package is in alpha and actively being developed. "
-    "Please avoid running mission-critical workloads on resources deployed "
-    "through these commands. If you encounter any problems, create an issue "
-    f"on the repository {STACK_RECIPES_GITHUB_REPO} and we'll help you out!"
-)
-NOT_INSTALLED_MESSAGE = (
-    "The prerequisites for using `mlstacks` (the `mlstacks` and "
-    "`python-terraform` packages seem to be unavailable on your machine "
-    "and/or in your environment. To install the missing dependencies: \n\n"
-    "`pip install mlstacks`"
-)
-TERRAFORM_NOT_INSTALLED_MESSAGE = (
-    "Terraform appears not to be installed on your machine and/or in your "
-    "environment. Please install Terraform and try again."
-)
-STACK_RECIPE_MODULAR_RECIPES = ["aws", "gcp", "k3d"]
-MLSTACKS_SUPPORTED_STACK_COMPONENTS = [
-    "artifact_store",
-    "container_registry",
-    "experiment_tracker",
-    "orchestrator",
-    "model_deployer",
-    "mlops_platform",
-    "step_operator",
-]
-
 
 # Parameters for internal ZenML Models
 TEXT_FIELD_MAX_LENGTH = 65535

zenml/enums.py

@@ -200,9 +200,6 @@ class ServerProviderType(StrEnum):
 
     LOCAL = "local"
     DOCKER = "docker"
-    AWS = "aws"
-    GCP = "gcp"
-    AZURE = "azure"
 
 
 class AnalyticsEventSource(StrEnum):