content: #  Copyright (c) ZenML GmbH 2023. 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.
  """ZenML CLI.
  
  How to use the CLI
  ------------------
  
  Our CLI behaves similarly to many other CLIs for basic features. In
  order to find out which version of ZenML you are running, type:
  
  ```bash
     zenml version
  ```
  
  If you ever need more information on exactly what a certain command will
  do, use the ``--help`` flag attached to the end of your command string.
  
  For example, to get a sense of all the commands available to you
  while using the ``zenml`` command, type:
  
  ```bash
     zenml --help
  ```
  
  If you were instead looking to know more about a specific command, you
  can type something like this:
  
  ```bash
     zenml artifact-store register --help
  ```
  
  This will give you information about how to register an artifact store.
  (See below for more on that).
  
  If you want to instead understand what the concept behind a group is, you 
  can use the `explain` sub-command. For example, to see more details behind 
  what a `artifact-store` is, you can type:
  
  ```bash
  zenml artifact-store explain
  ```
  
  This will give you an explanation of that concept in more detail.
  
  Beginning a Project
  -------------------
  
  In order to start working on your project, initialize a ZenML repository
  within your current directory with ZenML's own config and resource management
  tools:
  
  ```bash
  zenml init
  ```
  
  This is all you need to begin using all the MLOps goodness that ZenML
  provides!
  
  By default, ``zenml init`` will install its own hidden ``.zen`` folder
  inside the current directory from which you are running the command.
  You can also pass in a directory path manually using the
  ``--path`` option:
  
  ```bash
  zenml init --path /path/to/dir
  ```
  
  If you wish to use one of [the available ZenML project templates](https://docs.zenml.io/user-guides/best-practices/project-templates)
  to generate a ready-to-use project scaffold in your repository, you can do so by
  passing the ``--template`` option:
  
  ```bash
  zenml init --template <name_of_template>
  ```
  
  Running the above command will result in input prompts being shown to you. If 
  you would like to rely on default values for the ZenML project template - 
  you can add ``--template-with-defaults`` to the same command, like this:
  
  ```bash
  zenml init --template <name_of_template> --template-with-defaults
  ```
  
  In a similar fashion, if you would like to quickly explore the capabilities
  of ZenML through a notebook, you can also use:
  
  ```bash
  zenml go
  ```
  
  Cleaning up
  -----------
  
  If you wish to delete all data relating to your project from the
  directory, use the ``zenml clean`` command. This will:
  
  -  delete all pipelines, pipeline runs and associated metadata
  -  delete all artifacts
  
  Using Integrations
  ------------------
  
  Integrations are the different pieces of a project stack that enable custom
  functionality. This ranges from bigger libraries like
  [`kubeflow`](https://www.kubeflow.org/) for orchestration down to smaller
  visualization tools like [`facets`](https://pair-code.github.io/facets/). Our
  CLI is an easy way to get started with these integrations.
  
  To list all the integrations available to you, type:
  
  ```bash
  zenml integration list
  ```
  
  To see the requirements for a specific integration, use the `requirements`
  command:
  
  ```bash
  zenml integration requirements INTEGRATION_NAME
  ```
  
  If you wish to install the integration, using the requirements listed in the
  previous command, `install` allows you to do this for your local environment:
  
  ```bash
  zenml integration install INTEGRATION_NAME
  ```
  
  Note that if you don't specify a specific integration to be installed, the
  ZenML CLI will install **all** available integrations.
  
  If you want to install all integrations apart from one or multiple integrations,
  use the following syntax, for example, which will install all integrations
  except `feast` and `aws`:
  
  ```shell
  zenml integration install -i feast -i aws
  ```
  
  Uninstalling a specific integration is as simple as typing:
  
  ```bash
  zenml integration uninstall INTEGRATION_NAME
  ```
  
  For all these `zenml integration` commands, you can pass the `--uv` flag and we
  will use `uv` as the package manager instead of `pip`. This will resolve and
  install much faster than with `pip`, but note that it requires `uv` to be
  installed on your machine. This is an experimental feature and may not work on
  all systems. In particular, note that installing onto machines with GPU
  acceleration may not work as expected.
  
  If you would like to export the requirements of all ZenML integrations, you can
  use the command:
  
  ```bash
  zenml integration export-requirements
  ```
  
  Here, you can also select a list of integrations and write the result into and
  output file:
  
  ```bash
  zenml integration export-requirements gcp kubeflow -o OUTPUT_FILE
  ```
  
  Filtering when listing
  ----------------------
  
  Certain CLI `list` commands allow you to filter their output. For example, all
  stack components allow you to pass custom parameters to the `list` command that
  will filter the output. To learn more about the available filters, a good quick
  reference is to use the `--help` command, as in the following example:
  
  ```shell
  zenml orchestrator list --help
  ```
  
  You will see a list of all the available filters for the `list` command along
  with examples of how to use them.
  
  The `--sort_by` option allows you to sort the output by a specific field and
  takes an `asc` or `desc` argument to specify the order. For example, to sort the
  output of the `list` command by the `name` field in ascending order, you would
  type:
  
  ```shell
  zenml orchestrator list --sort_by "asc:name"
  ```
  
  For fields marked as being of type `TEXT` or `UUID`, you can use the `contains`,
  `startswith` and `endswith` keywords along with their particular identifier. For
  example, for the orchestrator `list` command, you can use the following filter
  to find all orchestrators that contain the string `sagemaker` in their name:
  
  ```shell
  zenml orchestrator list --name "contains:sagemaker"
  ```
  
  For fields marked as being of type `BOOL`, you can use the 'True' or 'False'
  values to filter the output.
  
  Finally, for fields marked as being of type `DATETIME`, you can pass in datetime
  values in the `%Y-%m-%d %H:%M:%S` format. These can be combined with the `gte`,
  `lte`, `gt` and `lt` keywords (greater than or equal, less than or equal,
  greater than and less than respectively) to specify the range of the filter. For
  example, if I wanted to find all orchestrators that were created after the 1st
  of January 2021, I would type:
  
  ```shell
  zenml orchestrator list --created "gt:2021-01-01 00:00:00"
  ```
  
  This syntax can also be combined to create more complex filters using the `or`
  and `and` keywords.
  
  Output formats
  --------------
  
  All ``list`` commands support multiple output formats for scripting,
  CI/CD integration, and data analysis.
  
  Use the ``--output`` (or ``-o``) option to specify the format:
  
  ```bash
  # Get stack data as JSON for processing with jq
  zenml stack list --output=json | jq '.items[] | select(.name=="production")'
  
  # Export pipeline runs to CSV for analysis
  zenml pipeline runs list --output=csv > pipeline_runs.csv
  
  # Get deployment info as YAML for configuration management
  zenml deployment list --output=yaml
  
  # Filter columns to see only what you need
  zenml stack list --columns=id,name,orchestrator
  
  # Combine filtering with custom output formats
  zenml pipeline list --columns=id,name --output=json
  ```
  
  Available formats:
  
  - **json** - Structured data with pagination info, ideal for programmatic use
  - **yaml** - Human-readable structured format, great for configuration
  - **csv** - Comma-separated values for spreadsheets and data analysis
  - **tsv** - Tab-separated values for simpler parsing
  - **table** (default) - Formatted tables with colors and alignment
  
  You can also control the default output format and table width using
  environment variables:
  
  - ``ZENML_DEFAULT_OUTPUT`` - Set the default output format (e.g., ``json``)
  - ``ZENML_CLI_COLUMN_WIDTH`` - Override terminal width for consistent formatting
  
  Artifact Stores
  ---------------
  
  In ZenML, [the artifact store](https://docs.zenml.io/stacks/stack-components/artifact-stores)
  is where all the inputs and outputs of your pipeline steps are stored. By
  default, ZenML initializes your repository with an artifact store with
  everything kept on your local machine. You can get a better understanding
  about the concept of artifact stores by executing:
  
  ```bash
  zenml artifact-store explain
  ```
  
  If you wish to register a new artifact store, do so with the ``register``
  command:
  
  ```bash
  zenml artifact-store register ARTIFACT_STORE_NAME --flavor=ARTIFACT_STORE_FLAVOR [--OPTIONS]
  ```
  
  You can also add any labels to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml artifact-store register ARTIFACT_STORE_NAME --flavor=ARTIFACT_STORE_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new artifact store,
  you have to choose a flavor. To see the full list of available artifact
  store flavors, you can use the command:
  
  ```bash
  zenml artifact-store flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml artifact-store flavor describe FLAVOR_NAME
  ```
  
  If you wish to list the artifact stores that have already been registered
  within your ZenML:
  
  ```bash
  zenml artifact-store list
  ```
  
  If you want the name of the artifact store in the active stack, you can
  also use the `get` command:
  
  ```bash
  zenml artifact-store get
  ```
  
  For details about a particular artifact store, use the `describe` command.
  By default, (without a specific artifact store name passed in) it will describe
  the active or currently used artifact store:
  
  ```bash
  zenml artifact-store describe ARTIFACT_STORE_NAME
  ```
  
  If you wish to update/rename an artifact store, you can use the following
  commands respectively:
  
  ```bash
  zenml artifact-store update ARTIFACT_STORE_NAME --property_to_update=new_value
  zenml artifact-store rename ARTIFACT_STORE_OLD_NAME ARTIFACT_STORE_NEW_NAME
  ```
  
  If you wish to delete a particular artifact store, pass the name of the
  artifact store into the CLI with the following command:
  
  ```bash
  zenml artifact-store delete ARTIFACT_STORE_NAME
  ```
  
  If you would like to connect/disconnect your artifact store to/from a service
  connector, you can use the following commands:
  
  ```bash
  zenml artifact-store connect ARTIFACT_STORE_NAME -c CONNECTOR_NAME
  zenml artifact-store disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  artifact stores. In order to get a full list of available functions, use
  the command:
  
  ```bash
  zenml artifact-store --help
  ```
  
  Orchestrators
  -------------
  
  An [orchestrator](https://docs.zenml.io/stacks/stack-components/orchestrators)
  is a special kind of backend that manages the running of each step of the
  pipeline. Orchestrators administer the actual pipeline runs. By default,
  ZenML initializes your repository with an orchestrator that runs everything
  on your local machine. In order to get a more detailed explanation, you can use
  the command:
  
  ```bash
  zenml orchestrator explain
  ```
  
  If you wish to register a new orchestrator, do so with the ``register``
  command:
  
  ```bash
  zenml orchestrator register ORCHESTRATOR_NAME --flavor=ORCHESTRATOR_FLAVOR [--ORCHESTRATOR_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml orchestrator register ORCHESTRATOR_NAME --flavor=ORCHESTRATOR_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new orchestrator,
  you have to choose a flavor. To see the full list of available orchestrator
  flavors, you can use the command:
  
  ```bash
  zenml orchestrator flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml orchestrator flavor describe FLAVOR_NAME
  ```
  
  If you wish to list the orchestrators that have already been registered, type:
  
  ```bash
  zenml orchestrator list
  ```
  
  If you want the name of the orchestrator in the active stack, you can
  also use the `get` command:
  
  ```bash
  zenml orchestrator get
  ```
  
  For details about a particular orchestrator, use the `describe` command.
  By default, (without a specific orchestrator name passed in) it will describe
  the active or currently used orchestrator:
  
  ```bash
  zenml orchestrator describe [ORCHESTRATOR_NAME]
  ```
  
  If you wish to update/rename an orchestrator, you can use the following
  commands respectively:
  
  ```bash
  zenml orchestrator update ORCHESTRATOR_NAME --property_to_update=new_value
  zenml orchestrator rename ORCHESTRATOR_OLD_NAME ORCHESTRATOR_NEW_NAME
  ```
  
  If you wish to delete a particular orchestrator, pass the name of the
  orchestrator into the CLI with the following command:
  
  ```bash
  zenml orchestrator delete ORCHESTRATOR_NAME
  ```
  
  If you would like to connect/disconnect your orchestrator to/from a service
  connector, you can use the following commands:
  
  ```bash
  zenml orchestrator connect ORCHESTRATOR_NAME -c CONNECTOR_NAME
  zenml orchestrator disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  orchestrators. In order to get a full list of available functions, use
  the command:
  
  ```bash
  zenml orchestrators --help
  ```
  
  Container Registries
  --------------------
  
  [The container registry](https://docs.zenml.io/stacks/stack-components/container-registries)
  is where all the images that are used by a container-based orchestrator are
  stored. To get a better understanding regarding container registries, use
  the command:
  
  ```bash
  zenml container-registry explain
  ```
  
  By default, a default ZenML local stack will not register a container registry.
  If you wish to register a new container registry, do so with the `register`
  command:
  
  ```bash
  zenml container-registry register REGISTRY_NAME --flavor=REGISTRY_FLAVOR [--REGISTRY_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml container-registry register REGISTRY_NAME --flavor=REGISTRY_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new container
  registry, you have to choose a flavor. To see the full list of available
  container registry flavors, you can use the command:
  
  ```bash
  zenml container-registry flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml container-registry flavor describe FLAVOR_NAME
  ```
  
  To list all container registries available and registered for use, use the
  `list` command:
  
  ```bash
  zenml container-registry list
  ```
  
  If you want the name of the container registry in the active stack, you can
  also use the `get` command:
  
  ```bash
  zenml container-registry get
  ```
  
  For details about a particular container registry, use the `describe` command.
  By default, (without a specific registry name passed in) it will describe the
  active or currently used container registry:
  
  ```bash
  zenml container-registry describe [CONTAINER_REGISTRY_NAME]
  ```
  
  If you wish to update/rename a container registry, you can use the following
  commands respectively:
  
  ```bash
  zenml container-registry update CONTAINER_REGISTRY_NAME --property_to_update=new_value
  zenml container-registry rename CONTAINER_REGISTRY_OLD_NAME CONTAINER_REGISTRY_NEW_NAME
  ```
  
  To delete a container registry (and all of its contents), use the `delete`
  command:
  
  ```bash
  zenml container-registry delete REGISTRY_NAME
  ```
  
  If you would like to connect/disconnect your container registry to/from a
  service connector, you can use the following commands:
  
  ```bash
  zenml container-registry connect CONTAINER_REGISTRY_NAME -c CONNECTOR_NAME
  zenml container-registry disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  container registries. In order to get a full list of available functions,
  use the command:
  
  ```bash
  zenml container-registry --help
  ```
  
  Data Validators
  ---------------
  
  In ZenML, [data validators](https://docs.zenml.io/stacks/stack-components/data-validators)
  help you profile and validate your data.
  
  By default, a default ZenML local stack will not register a data validator. If
  you wish to register a new data validator, do so with the `register` command:
  
  ```bash
  zenml data-validator register DATA_VALIDATOR_NAME --flavor DATA_VALIDATOR_FLAVOR [--DATA_VALIDATOR_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml data-validator register DATA_VALIDATOR_NAME --flavor DATA_VALIDATOR_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new data validator,
  you have to choose a flavor. To see the full list of available data validator
  flavors, you can use the command:
  
  ```bash
  zenml data-validator flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml data-validator flavor describe FLAVOR_NAME
  ```
  
  To list all data validators available and registered for use, use the `list`
  command:
  
  ```bash
  zenml data-validator list
  ```
  
  If you want the name of the data validator in the active stack, use the `get`
  command:
  
  ```bash
  zenml data-validator get
  ```
  
  For details about a particular data validator, use the `describe` command.
  By default, (without a specific data validator name passed in) it will describe
  the active or currently-used data validator:
  
  ```bash
  zenml data-validator describe [DATA_VALIDATOR_NAME]
  ```
  
  If you wish to update/rename a data validator, you can use the following
  commands respectively:
  
  ```bash
  zenml data-validator update DATA_VALIDATOR_NAME --property_to_update=new_value
  zenml data-validator rename DATA_VALIDATOR_OLD_NAME DATA_VALIDATOR_NEW_NAME
  ```
  
  To delete a data validator (and all of its contents), use the `delete` command:
  
  ```bash
  zenml data-validator delete DATA_VALIDATOR_NAME
  ```
  
  If you would like to connect/disconnect your data validator to/from a service
  connector, you can use the following commands:
  
  ```bash
  zenml data-validator connect DATA_VALIDATOR_NAME -c CONNECTOR_NAME
  zenml data-validator disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  data validators. In order to get a full list of available functions, use the
  command:
  
  ```bash
  zenml data-validator --help
  ```
  
  Experiment Trackers
  -------------------
  
  [Experiment trackers](https://docs.zenml.io/stacks/stack-components/experiment-trackers)
   let you track your ML experiments by logging the parameters
  and allow you to compare between different runs. To get a better
  understanding regarding experiment trackers, use the command:
  
  ```bash
  zenml experiment-tracker explain
  ```
  
  By default, a default ZenML local stack will not register an experiment tracker.
  If you want to use an experiment tracker in one of your stacks, you need to
  first register it:
  
  ```bash
  zenml experiment-tracker register EXPERIMENT_TRACKER_NAME \
      --flavor=EXPERIMENT_TRACKER_FLAVOR [--EXPERIMENT_TRACKER_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml experiment-tracker register EXPERIMENT_TRACKER_NAME \
        --flavor=EXPERIMENT_TRACKER_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new experiment
  tracker, you have to choose a flavor. To see the full list of available
  experiment tracker flavors, you can use the command:
  
  ```bash
  zenml experiment-tracker flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml experiment-tracker flavor describe FLAVOR_NAME
  ```
  
  To list all experiment trackers available and registered for use, use the
  `list` command:
  
  ```bash
  zenml experiment-tracker list
  ```
  
  If you want the name of the experiment tracker in the active stack, use the
  `get` command:
  
  ```bash
  zenml experiment-tracker get
  ```
  
  For details about a particular experiment tracker, use the `describe` command.
  By default, (without a specific experiment tracker name passed in) it will
  describe the active or currently-used experiment tracker:
  
  ```bash
  zenml experiment-tracker describe [EXPERIMENT_TRACKER_NAME]
  ```
  
  If you wish to update/rename an experiment tracker, you can use the following
  commands respectively:
  
  ```bash
  zenml experiment-tracker update EXPERIMENT_TRACKER_NAME --property_to_update=new_value
  zenml experiment-tracker rename EXPERIMENT_TRACKER_OLD_NAME EXPERIMENT_TRACKER_NEW_NAME
  ```
  
  To delete an experiment tracker, use the `delete` command:
  
  ```bash
  zenml experiment-tracker delete EXPERIMENT_TRACKER_NAME
  ```
  
  If you would like to connect/disconnect your experiment tracker to/from a
  service connector, you can use the following commands:
  
  ```bash
  zenml experiment-tracker connect EXPERIMENT_TRACKER_NAME -c CONNECTOR_NAME
  zenml experiment-tracker disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  experiment trackers. In order to get a full list of available functions,
  use the command:
  
  ```bash
  zenml experiment-tracker --help
  ```
  
  Model Deployers
  ---------------
  
  [Model deployers](https://docs.zenml.io/stacks/stack-components/model-deployers)
  are stack components responsible for online model serving. They are responsible
  for deploying models to a remote server. Model deployers also act as a registry
  for models that are served with ZenML. To get a better understanding regarding
  model deployers, use the command:
  
  ```bash
  zenml model-deployer explain
  ```
  
  By default, a default ZenML local stack will not register a model deployer. If
  you wish to register a new model deployer, do so with the `register` command:
  
  ```bash
  zenml model-deployer register MODEL_DEPLOYER_NAME --flavor MODEL_DEPLOYER_FLAVOR [--MODEL_DEPLOYER_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml model-deployer register MODEL_DEPLOYER_NAME --flavor MODEL_DEPLOYER_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new model deployer,
  you have to choose a flavor. To see the full list of available model deployer
  flavors, you can use the command:
  
  ```bash
  zenml model-deployer flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml model-deployer flavor describe FLAVOR_NAME
  ```
  
  To list all model deployers available and registered for use, use the
  `list` command:
  
  ```bash
  zenml model-deployer list
  ```
  
  If you want the name of the model deployer in the active stack, use the `get`
  command:
  
  ```bash
  zenml model-deployer get
  ```
  
  For details about a particular model deployer, use the `describe` command.
  By default, (without a specific operator name passed in) it will describe the
  active or currently used model deployer:
  
  ```bash
  zenml model-deployer describe [MODEL_DEPLOYER_NAME]
  ```
  
  If you wish to update/rename a model deployer, you can use the following
  commands respectively:
  
  ```bash
  zenml model-deployer update MODEL_DEPLOYER_NAME --property_to_update=new_value
  zenml model-deployer rename MODEL_DEPLOYER_OLD_NAME MODEL_DEPLOYER_NEW_NAME
  ```
  
  To delete a model deployer (and all of its contents), use the `delete`
  command:
  
  ```bash
  zenml model-deployer delete MODEL_DEPLOYER_NAME
  ```
  
  If you would like to connect/disconnect your model deployer to/from a
  service connector, you can use the following commands:
  
  ```bash
  zenml model-deployer connect MODEL_DEPLOYER_NAME -c CONNECTOR_NAME
  zenml model-deployer disconnect
  ```
  
  Moreover, ZenML features a set of CLI commands specific to the model deployer
  interface. If you want to simply see what models have been deployed within
  your stack, run the following command:
  
  ```bash
  zenml model-deployer models list
  ```
  
  This should give you a list of served models containing their `uuid`, the name
  of the pipeline that produced them including the run id and the step name as
  well as the status. This information should help you identify the different
  models.
  
  If you want further information about a specific model, simply copy the
  UUID and the following command.
  
  ```bash
  zenml model-deployer models describe <UUID>
  ```
  
  If you are only interested in the prediction url of the specific model you can
  also run:
  
  ```bash
  zenml model-deployer models get-url <UUID>
  ```
  
  Finally, you will also be able to start/stop the services using the following
   two commands:
  
  ```bash
  zenml model-deployer models start <UUID>
  zenml model-deployer models stop <UUID>
  ```
  
  If you want to completely remove a served model you can also irreversibly delete
   it using:
  
  ```bash
  zenml model-deployer models delete <UUID>
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  model deployers. In order to get a full list of available functions,
  use the command:
  
  ```bash
  zenml model-deployer --help
  ```
  
  Step Operators
  --------------
  
  [Step operators](https://docs.zenml.io/stacks/stack-components/step-operators)
  allow you to run individual steps in a custom environment different from the
  default one used by your active orchestrator. One example use-case is to run a
  training step of your pipeline in an environment with GPUs available. To get
  a better understanding regarding step operators, use the command:
  
  ```bash
  zenml step-operator explain
  ```
  
  By default, a default ZenML local stack will not register a step operator. If
  you wish to register a new step operator, do so with the `register` command:
  
  ```bash
  zenml step-operator register STEP_OPERATOR_NAME --flavor STEP_OPERATOR_FLAVOR [--STEP_OPERATOR_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml step-operator register STEP_OPERATOR_NAME --flavor STEP_OPERATOR_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new step operator,
  you have to choose a flavor. To see the full list of available step operator
  flavors, you can use the command:
  
  ```bash
  zenml step-operator flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml step-operator flavor describe FLAVOR_NAME
  ```
  
  To list all step operators available and registered for use, use the
  `list` command:
  
  ```bash
  zenml step-operator list
  ```
  
  If you want the name of the step operator in the active stack, use the `get`
  command:
  
  ```bash
  zenml step-operator get
  ```
  
  For details about a particular step operator, use the `describe` command.
  By default, (without a specific operator name passed in) it will describe the
  active or currently used step operator:
  
  ```bash
  zenml step-operator describe [STEP_OPERATOR_NAME]
  ```
  
  If you wish to update/rename a step operator, you can use the following commands
  respectively:
  
  ```bash
  zenml step-operator update STEP_OPERATOR_NAME --property_to_update=new_value
  zenml step-operator rename STEP_OPERATOR_OLD_NAME STEP_OPERATOR_NEW_NAME
  ```
  
  To delete a step operator (and all of its contents), use the `delete`
  command:
  
  ```bash
  zenml step-operator delete STEP_OPERATOR_NAME
  ```
  
  If you would like to connect/disconnect your step operator to/from a
  service connector, you can use the following commands:
  
  ```bash
  zenml step-operator connect STEP_OPERATOR_NAME -c CONNECTOR_NAME
  zenml step-operator disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  step operators. In order to get a full list of available functions,
  use the command:
  
  ```bash
  zenml step-operator --help
  ```
  
  Alerters
  --------
  
  In ZenML, [alerters](https://docs.zenml.io/stacks/stack-components/alerters)
  allow you to send alerts from within your pipeline.
  
  By default, a default ZenML local stack will not register an alerter. If
  you wish to register a new alerter, do so with the `register` command:
  
  ```bash
  zenml alerter register ALERTER_NAME --flavor ALERTER_FLAVOR [--ALERTER_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml alerter register ALERTER_NAME --flavor ALERTER_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new alerter,
  you have to choose a flavor. To see the full list of available alerter
  flavors, you can use the command:
  
  ```bash
  zenml alerter flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  ```bash
  zenml alerter flavor describe FLAVOR_NAME
  ```
  
  To list all alerters available and registered for use, use the `list` command:
  
  ```bash
  zenml alerter list
  ```
  
  If you want the name of the alerter in the active stack, use the `get`
  command:
  
  ```bash
  zenml alerter get
  ```
  
  For details about a particular alerter, use the `describe` command.
  By default, (without a specific alerter name passed in) it will describe
  the active or currently used alerter:
  
  ```bash
  zenml alerter describe [ALERTER_NAME]
  ```
  
  If you wish to update/rename an alerter, you can use the following commands
  respectively:
  
  ```bash
  zenml alerter update ALERTER_NAME --property_to_update=new_value
  zenml alerter rename ALERTER_OLD_NAME ALERTER_NEW_NAME
  ```
  
  To delete an alerter (and all of its contents), use the `delete` command:
  
  ```bash
  zenml alerter delete ALERTER_NAME
  ```
  
  If you would like to connect/disconnect your alerter to/from a service
  connector, you can use the following commands:
  
  ```bash
  zenml alerter connect ALERTER_NAME -c CONNECTOR_NAME
  zenml alerter disconnect
  ```
  
  The ZenML CLI provides a few more utility functions for you to manage your
  alerters. In order to get a full list of available functions, use the command:
  
  ```bash
  zenml alerter --help
  ```
  
  Feature Stores
  --------------
  
  [Feature stores](https://docs.zenml.io/stacks/stack-components/feature-stores)
  allow data teams to serve data via an offline store and an online low-latency
  store where data is kept in sync between the two. To get a better understanding
  regarding feature stores, use the command:
  
  ```bash
  zenml feature-store explain
  ```
  
  By default, a default ZenML local stack will not register a feature store. If
  you wish to register a new feature store, do so with the `register` command:
  
  ```bash
  zenml feature-store register FEATURE_STORE_NAME --flavor FEATURE_STORE_FLAVOR [--FEATURE_STORE_OPTIONS]
  ```
  
  You can also add any label to your stack component using the `--label` or `-l` flag:
  
  ```bash
  zenml feature-store register FEATURE_STORE_NAME --flavor FEATURE_STORE_FLAVOR -l key1=value1 -l key2=value2
  ```
  
  As you can see from the command above, when you register a new feature store,
  you have to choose a flavor. To see the full list of available feature store
  flavors, you can use the command:
  
  ```bash
  zenml feature-store flavor list
  ```
  
  This list will show you which integration these flavors belong to and which
  service connectors they are adaptable with. If you would like to get additional
  information regarding a specific flavor, you can utilize the command:
  
  Note: Currently, ZenML only supports connecting to a Redis-backed Feast feature
  