zenml-nightly 0.67.0.dev20241002__py3-none-any.whl → 0.68.0.dev20241027__py3-none-any.whl

zenml/cli/stack_components.py

@@ -13,9 +13,6 @@
 #  permissions and limitations under the License.
 """Functionality to generate stack component CLI commands."""
 
-import os
-import random
-import string
 import time
 from importlib import import_module
 from typing import Any, Callable, List, Optional, Tuple, cast
@@ -24,8 +21,6 @@ from uuid import UUID
 import click
 from rich.markdown import Markdown
 
-from zenml.analytics.enums import AnalyticsEvent
-from zenml.analytics.utils import track_handler
 from zenml.cli import utils as cli_utils
 from zenml.cli.annotator import register_annotator_subcommands
 from zenml.cli.cli import TagGroup, cli
@@ -41,7 +36,6 @@ from zenml.cli.utils import (
 )
 from zenml.client import Client
 from zenml.console import console
-from zenml.constants import ALPHA_MESSAGE, STACK_RECIPE_MODULAR_RECIPES
 from zenml.enums import CliCategories, StackComponentType
 from zenml.exceptions import AuthorizationException, IllegalOperationError
 from zenml.io import fileio
@@ -51,14 +45,6 @@ from zenml.models import (
 )
 from zenml.utils import source_utils
 from zenml.utils.dashboard_utils import get_component_url
-from zenml.utils.io_utils import create_dir_recursive_if_not_exists
-from zenml.utils.mlstacks_utils import (
-    convert_click_params_to_mlstacks_primitives,
-    convert_mlstacks_primitives_to_dicts,
-    import_new_mlstacks_component,
-    verify_spec_and_tf_files_exist,
-)
-from zenml.utils.yaml_utils import write_yaml
 
 
 def generate_stack_component_get_command(
@@ -595,162 +581,6 @@ def generate_stack_component_copy_command(
     return copy_stack_component_command
 
 
-def generate_stack_component_up_command(
-    component_type: StackComponentType,
-) -> Callable[[str], None]:
-    """Generates a `up` command for the specific stack component type.
-
-    Args:
-        component_type: Type of the component to generate the command for.
-
-    Returns:
-        A function that can be used as a `click` command.
-    """
-    display_name = _component_display_name(component_type)
-
-    @click.argument("name_id_or_prefix", type=str, required=False)
-    def up_stack_component_command(name_id_or_prefix: str) -> None:
-        """Deploys a stack component locally.
-
-        Args:
-            name_id_or_prefix: The name or_id of the stack component to deploy.
-        """
-        client = Client()
-
-        with console.status(
-            f"Provisioning {display_name} '{name_id_or_prefix}' locally...\n"
-        ):
-            try:
-                component_model = client.get_stack_component(
-                    name_id_or_prefix=name_id_or_prefix,
-                    component_type=component_type,
-                )
-            except KeyError as err:
-                cli_utils.error(str(err))
-
-            from zenml.stack import StackComponent
-
-            component = StackComponent.from_model(
-                component_model=component_model
-            )
-
-            if component.is_running:
-                cli_utils.declare(
-                    f"Local deployment is already running for {display_name} "
-                    f"'{component.name}'."
-                )
-                return
-
-            if not component.is_provisioned:
-                cli_utils.declare(
-                    f"Provisioning local resources for {display_name} "
-                    f"'{component.name}'."
-                )
-                try:
-                    component.provision()
-                except NotImplementedError:
-                    cli_utils.error(
-                        f"Provisioning local resources not implemented for "
-                        f"{display_name} '{component.name}'."
-                    )
-
-            if not component.is_running:
-                cli_utils.declare(
-                    f"Resuming local resources for {display_name} "
-                    f"'{component.name}'."
-                )
-                component.resume()
-
-    return up_stack_component_command
-
-
-def generate_stack_component_down_command(
-    component_type: StackComponentType,
-) -> Callable[[str, bool], None]:
-    """Generates a `down` command for the specific stack component type.
-
-    Args:
-        component_type: Type of the component to generate the command for.
-
-    Returns:
-        A function that can be used as a `click` command.
-    """
-    display_name = _component_display_name(component_type)
-
-    @click.argument("name_id_or_prefix", type=str, required=False)
-    @click.option(
-        "--force",
-        "-f",
-        "force",
-        is_flag=True,
-        help="Deprovisions local resources instead of suspending them.",
-    )
-    def down_stack_component_command(
-        name_id_or_prefix: str,
-        force: bool = False,
-    ) -> None:
-        """Stops/Tears down the local deployment of a stack component.
-
-        Args:
-            name_id_or_prefix: The name or id of the component to
-                stop/deprovision.
-            force: Deprovision local resources instead of suspending them.
-        """
-        client = Client()
-
-        with console.status(
-            f"De-provisioning {display_name} '{name_id_or_prefix}' locally...\n"
-        ):
-            try:
-                component_model = client.get_stack_component(
-                    name_id_or_prefix=name_id_or_prefix,
-                    component_type=component_type,
-                )
-            except KeyError as err:
-                cli_utils.error(str(err))
-
-            from zenml.stack import StackComponent
-
-            component = StackComponent.from_model(
-                component_model=component_model
-            )
-
-            if not force:
-                if not component.is_suspended:
-                    cli_utils.declare(
-                        f"Suspending local resources for {display_name} "
-                        f"'{component.name}'."
-                    )
-                    try:
-                        component.suspend()
-                    except NotImplementedError:
-                        cli_utils.error(
-                            f"Provisioning local resources not implemented for "
-                            f"{display_name} '{component.name}'. If you want "
-                            f"to deprovision all resources for this component, "
-                            f"use the `--force/-f` flag."
-                        )
-                else:
-                    cli_utils.declare(
-                        f"No running resources found for {display_name} "
-                        f"'{component.name}'."
-                    )
-            else:
-                if component.is_provisioned:
-                    cli_utils.declare(
-                        f"Deprovisioning resources for {display_name} "
-                        f"'{component.name}'."
-                    )
-                    component.deprovision()
-                else:
-                    cli_utils.declare(
-                        f"No provisioned resources found for {display_name} "
-                        f"'{component.name}'."
-                    )
-
-    return down_stack_component_command
-
-
 def generate_stack_component_logs_command(
     component_type: StackComponentType,
 ) -> Callable[[str, bool], None]:
@@ -1063,382 +893,6 @@ def generate_stack_component_flavor_delete_command(
     return delete_stack_component_flavor_command
 
 
-def generate_stack_component_deploy_command(
-    component_type: StackComponentType,
-) -> Callable[
-    [str, str, str, str, bool, Optional[List[str]], List[str]], None
-]:
-    """Generates a `deploy` command for the stack component type.
-
-    Args:
-        component_type: Type of the component to generate the command for.
-
-    Returns:
-        A function that can be used as a `click` command.
-    """
-    display_name = _component_display_name(component_type)
-
-    @click.argument(
-        "name",
-        type=str,
-    )
-    @click.option(
-        "--flavor",
-        "-f",
-        "flavor",
-        help=f"The flavor of the {display_name} to deploy.",
-        required=True,
-        type=str,
-    )
-    @click.option(
-        "--provider",
-        "-p",
-        "provider",
-        required=True,
-        type=click.Choice(STACK_RECIPE_MODULAR_RECIPES),
-        help="The cloud (or local provider) to use to deploy the stack component.",
-    )
-    @click.option(
-        "--region",
-        "-r",
-        "region",
-        required=True,
-        type=str,
-        help="The region to deploy the stack component to.",
-    )
-    @click.option(
-        "--debug-mode",
-        "-d",
-        "debug_mode",
-        is_flag=True,
-        default=False,
-        help="Whether to deploy the stack component in debug mode.",
-    )
-    @click.option(
-        "--extra-config",
-        "-x",
-        "extra_config",
-        multiple=True,
-        help="Extra configurations as key=value pairs. This option can be "
-        "used multiple times.",
-    )
-    @click.option(
-        "--tags",
-        "-t",
-        "tags",
-        required=False,
-        type=click.STRING,
-        help="Pass one or more tags.",
-        multiple=True,
-    )
-    def deploy_stack_component_command(
-        name: str,
-        flavor: str,
-        provider: str,
-        region: str,
-        debug_mode: bool = False,
-        tags: Optional[List[str]] = None,
-        extra_config: List[str] = [],
-    ) -> None:
-        """Deploy a stack component.
-
-        This function also registers the newly-deployed component.
-
-        Args:
-            name: Name of the component to register.
-            flavor: Flavor of the component to register.
-            provider: Cloud provider (or local) to use to deploy the stack
-                component.
-            region: Region to deploy the stack component to.
-            debug_mode: Whether to deploy the stack component in debug mode.
-            tags: Tags to be added to the component.
-            extra_config: Extra configuration values to be added to the
-        """
-        with track_handler(
-            event=AnalyticsEvent.DEPLOY_STACK_COMPONENT,
-        ) as analytics_handler:
-            client = Client()
-            try:
-                # raise error if user already has a component with the same name
-                client.get_stack_component(
-                    component_type=component_type,
-                    name_id_or_prefix=name,
-                    allow_name_prefix_match=False,
-                )
-                cli_utils.error(
-                    f"A stack component of type '{component_type.value}' with "
-                    f"the name '{name}' already exists. Please try again with "
-                    f"a different component name."
-                )
-            except KeyError:
-                pass
-            from mlstacks.constants import ALLOWED_FLAVORS
-
-            if flavor not in ALLOWED_FLAVORS[component_type.value]:
-                cli_utils.error(
-                    f"Flavor '{flavor}' is not supported for "
-                    f"{_component_display_name(component_type, True)}. "
-                    "Allowed flavors are: "
-                    f"{', '.join(ALLOWED_FLAVORS[component_type.value])}."
-                )
-
-            # for cases like artifact store and container
-            # registry the flavor is the same as the cloud
-            if flavor in {"s3", "sagemaker", "aws"} and provider != "aws":
-                cli_utils.error(
-                    f"Flavor '{flavor}' is not supported for "
-                    f"{_component_display_name(component_type, True)} on "
-                    f"{provider}."
-                )
-            elif flavor in {"vertex", "gcp"} and provider != "gcp":
-                cli_utils.error(
-                    f"Flavor '{flavor}' is not supported for "
-                    f"{_component_display_name(component_type, True)} on "
-                    f"{provider}."
-                )
-
-            # if the cloud is gcp, project_id is required
-            extra_config_obj = (
-                dict(config.split("=") for config in extra_config)
-                if extra_config
-                else {}
-            )
-            if provider == "gcp" and "project_id" not in extra_config_obj:
-                cli_utils.error(
-                    "Missing Project ID. You must pass your GCP project ID to "
-                    "the deploy command as part of the `--extra_config` option."
-                )
-            cli_utils.declare("Checking prerequisites are installed...")
-            cli_utils.verify_mlstacks_prerequisites_installation()
-            from mlstacks.utils import zenml_utils
-
-            cli_utils.warning(ALPHA_MESSAGE)
-            cli_params = {
-                "provider": provider,
-                "region": region,
-                "stack_name": "".join(
-                    random.choice(string.ascii_letters + string.digits)
-                    for _ in range(5)
-                ),
-                "tags": tags,
-                "extra_config": list(extra_config),
-                "file": None,
-                "debug_mode": debug_mode,
-                component_type.value: flavor,
-            }
-            if component_type == StackComponentType.ARTIFACT_STORE:
-                cli_params["extra_config"].append(f"bucket_name={name}")  # type: ignore[union-attr]
-            stack, components = convert_click_params_to_mlstacks_primitives(
-                cli_params, zenml_component_deploy=True
-            )
-
-            analytics_handler.metadata = {
-                "flavor": flavor,
-                "provider": provider,
-                "debug_mode": debug_mode,
-                "component_type": component_type.value,
-            }
-
-            cli_utils.declare("Checking flavor compatibility...")
-            if not zenml_utils.has_valid_flavor_combinations(
-                stack, components
-            ):
-                cli_utils.error(
-                    "The specified stack and component flavors are not "
-                    "compatible with the provider or with one another. "
-                    "Please try again."
-                )
-
-            stack_dict, component_dicts = convert_mlstacks_primitives_to_dicts(
-                stack, components
-            )
-            # write the stack and component yaml files
-            from mlstacks.constants import MLSTACKS_PACKAGE_NAME
-
-            spec_dir = os.path.join(
-                click.get_app_dir(MLSTACKS_PACKAGE_NAME),
-                "stack_specs",
-                stack.name,
-            )
-            cli_utils.declare(f"Writing spec files to {spec_dir}...")
-            create_dir_recursive_if_not_exists(spec_dir)
-
-            stack_file_path = os.path.join(
-                spec_dir, f"stack-{stack.name}.yaml"
-            )
-            write_yaml(file_path=stack_file_path, contents=stack_dict)
-            for component in component_dicts:
-                write_yaml(
-                    file_path=os.path.join(
-                        spec_dir, f"{component['name']}.yaml"
-                    ),
-                    contents=component,
-                )
-
-            from mlstacks.utils import terraform_utils
-
-            cli_utils.declare("Deploying stack using Terraform...")
-            terraform_utils.deploy_stack(
-                stack_file_path, debug_mode=debug_mode
-            )
-            cli_utils.declare("Stack successfully deployed.")
-
-            stack_name: str = cli_params["stack_name"]  # type: ignore[assignment]
-            cli_utils.declare(
-                f"Importing {component_type.value} component '{name}' into ZenML..."
-            )
-            import_new_mlstacks_component(
-                stack_name=stack_name,
-                component_name=name,
-                provider=stack.provider,
-                stack_spec_dir=spec_dir,
-            )
-            cli_utils.declare("Component successfully imported into ZenML.")
-
-    return deploy_stack_component_command
-
-
-def generate_stack_component_destroy_command(
-    component_type: StackComponentType,
-) -> Callable[[str, str, bool], None]:
-    """Generates a `destroy` command for the stack component type.
-
-    Args:
-        component_type: Type of the component to generate the command for.
-
-    Returns:
-        A function that can be used as a `click` command.
-    """
-    _component_display_name(component_type)
-
-    @click.argument(
-        "name_id_or_prefix",
-        type=str,
-        required=True,
-    )
-    @click.option(
-        "--provider",
-        "-p",
-        "provider",
-        type=click.Choice(["aws", "k3d", "gcp"]),
-        required=True,
-    )
-    @click.option(
-        "--debug-mode",
-        "-d",
-        "debug_mode",
-        is_flag=True,
-        default=False,
-        help="Whether to destroy the stack component in debug mode.",
-    )
-    def destroy_stack_component_command(
-        name_id_or_prefix: str,
-        provider: str,
-        debug_mode: bool = False,
-    ) -> None:
-        """Destroy a stack component.
-
-        Args:
-            name_id_or_prefix: Name, ID or prefix of the component to destroy.
-            provider: Cloud provider (or local) where the stack was deployed.
-            debug_mode: Whether to destroy the stack component in debug mode.
-        """
-        with track_handler(
-            event=AnalyticsEvent.DESTROY_STACK_COMPONENT,
-        ) as analytics_handler:
-            analytics_handler.metadata = {
-                "provider": provider,
-                "component_type": component_type.value,
-                "debug_mode": debug_mode,
-            }
-            client = Client()
-
-            try:
-                component = client.get_stack_component(
-                    name_id_or_prefix=name_id_or_prefix,
-                    component_type=component_type,
-                    allow_name_prefix_match=False,
-                )
-            except KeyError:
-                cli_utils.error(
-                    "Could not find a stack component with name or id "
-                    f"'{name_id_or_prefix}'.",
-                )
-
-            # Check if the component was created by a recipe
-            if not component.component_spec_path:
-                cli_utils.error(
-                    f"Cannot destroy stack component {component.name}. It "
-                    "was not created by a recipe.",
-                )
-
-            cli_utils.verify_mlstacks_prerequisites_installation()
-            from mlstacks.constants import MLSTACKS_PACKAGE_NAME
-
-            # spec_files_dir: str = component.component_spec_path
-            component_spec_path: str = component.component_spec_path
-            stack_name: str = os.path.basename(
-                os.path.dirname(component_spec_path)
-            )
-            stack_spec_path: str = os.path.join(
-                os.path.dirname(component_spec_path),
-                f"stack-{stack_name}.yaml",
-            )
-            tf_definitions_path: str = os.path.join(
-                click.get_app_dir(MLSTACKS_PACKAGE_NAME),
-                "terraform",
-                f"{provider}-modular",
-            )
-
-            cli_utils.declare(
-                "Checking Terraform definitions and spec files are present..."
-            )
-            verify_spec_and_tf_files_exist(
-                stack_spec_path, tf_definitions_path
-            )
-
-            from mlstacks.utils import terraform_utils
-
-            cli_utils.declare(
-                f"Destroying component '{component.name}' using Terraform..."
-            )
-            terraform_utils.destroy_stack(
-                stack_path=stack_spec_path, debug_mode=debug_mode
-            )
-            cli_utils.declare(
-                f"Component '{component.name}' successfully destroyed."
-            )
-
-            if cli_utils.confirmation(
-                f"Would you like to delete the associated ZenML "
-                f"component '{component.name}'?\nThis will delete the stack "
-                "component registered with ZenML."
-            ):
-                client.delete_stack_component(
-                    name_id_or_prefix=component.id,
-                    component_type=component.type,
-                )
-                cli_utils.declare(
-                    f"Component '{component.name}' successfully deleted from ZenML."
-                )
-
-            spec_dir = os.path.dirname(stack_spec_path)
-            if cli_utils.confirmation(
-                f"Would you like to delete the `mlstacks` spec directory for "
-                f"this component, located at {spec_dir}?"
-            ):
-                fileio.rmtree(spec_dir)
-                cli_utils.declare(
-                    f"Spec directory for component '{component.name}' successfully "
-                    "deleted."
-                )
-            cli_utils.declare(
-                f"Component '{component.name}' successfully destroyed."
-            )
-
-    return destroy_stack_component_command
-
-
 def prompt_select_resource_id(
     resource_ids: List[str],
     resource_name: str,
@@ -1788,22 +1242,6 @@ def register_single_stack_component_cli_commands(
         "copy", help=f"Copy a registered {singular_display_name}."
     )(copy_command)
 
-    # zenml stack-component up
-    up_command = generate_stack_component_up_command(component_type)
-    command_group.command(
-        "up",
-        help=f"Provisions or resumes local resources for the "
-        f"{singular_display_name} if possible.",
-    )(up_command)
-
-    # zenml stack-component down
-    down_command = generate_stack_component_down_command(component_type)
-    command_group.command(
-        "down",
-        help=f"Suspends resources of the local {singular_display_name} "
-        f"deployment.",
-    )(down_command)
-
     # zenml stack-component logs
     logs_command = generate_stack_component_logs_command(component_type)
     command_group.command(
@@ -1832,22 +1270,6 @@ def register_single_stack_component_cli_commands(
         "explain", help=f"Explaining the {plural_display_name}."
     )(explain_command)
 
-    # zenml stack-component deploy
-    deploy_command = generate_stack_component_deploy_command(component_type)
-    context_settings = {"ignore_unknown_options": True}
-    command_group.command(
-        "deploy",
-        context_settings=context_settings,
-        help=f"Deploy a new {singular_display_name}.",
-    )(deploy_command)
-
-    # zenml stack-component destroy
-    destroy_command = generate_stack_component_destroy_command(component_type)
-    command_group.command(
-        "destroy",
-        help=f"Destroy an existing {singular_display_name}.",
-    )(destroy_command)
-
     # zenml stack-component flavor
     @command_group.group(
         "flavor", help=f"Commands to interact with {plural_display_name}."