Repository: zenml-io/zenml

Issue:
[BUG]: unable to successfully deploy azure stack recipe 
### Contact Details [Optional]

_No response_

### System Information

ZenML version: 0.33.0
Install path: /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/zenml
Python version: 3.10.8
Platform information: {'os': 'mac', 'mac_version': '13.2'}
Environment: native
Integrations: ['azure', 'github', 'kaniko', 'mlflow', 'pillow', 'scipy', 'sklearn']


[requirements.txt](https://github.com/zenml-io/zenml/files/10683614/requirements.txt)


### What happened?

`zenml stack recipe destroy azureml-minimal` doesn't recognize the "azureml-minimal" stack recipe name and throws the following error:
`TypeError: destroy() got multiple values for argument 'stack_recipe_name'`

Trying with quotes
`zenml stack recipe destroy "azureml-minimal"`

and variations of it, i.e.
`cd ./path/to/recipe && zenml stack recipe destroy .``

lead to the same error.

### Reproduction steps

1. zenml stack recipe pull azureml-minimal
2. update values
3. zenml stack recipe deploy azureml-minimal
4. zenml stack recipe destroy azureml-minimal


### Relevant log output

```shell
❯ zenml stack recipe destroy azureml-minimal
Using the default local database.
Running with active workspace: 'default' (repository)
╭─────────────────────────────── Traceback (most recent call last) ────────────────────────────────╮
│ /Users/fschulz/dev/learn-zenml/.venv/bin/zenml:8 in <module>                                     │
│                                                                                                  │
│   5 from zenml.cli.cli import cli                                                                │
│   6 if __name__ == '__main__':                                                                   │
│   7 │   sys.argv[0] = re.sub(r'(-script\.pyw|\.exe)?$', '', sys.argv[0])                         │
│ ❱ 8 │   sys.exit(cli())                                                                          │
│   9                                                                                              │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:1130 in __call__ │
│                                                                                                  │
│   1127 │                                                                                         │
│   1128 │   def __call__(self, *args: t.Any, **kwargs: t.Any) -> t.Any:                           │
│   1129 │   │   """Alias for :meth:`main`."""                                                     │
│ ❱ 1130 │   │   return self.main(*args, **kwargs)                                                 │
│   1131                                                                                           │
│   1132                                                                                           │
│   1133 class Command(BaseCommand):                                                               │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:1055 in main     │
│                                                                                                  │
│   1052 │   │   try:                                                                              │
│   1053 │   │   │   try:                                                                          │
│   1054 │   │   │   │   with self.make_context(prog_name, args, **extra) as ctx:                  │
│ ❱ 1055 │   │   │   │   │   rv = self.invoke(ctx)                                                 │
│   1056 │   │   │   │   │   if not standalone_mode:                                               │
│   1057 │   │   │   │   │   │   return rv                                                         │
│   1058 │   │   │   │   │   # it's not safe to `ctx.exit(rv)` here!                               │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:1657 in invoke   │
│                                                                                                  │
│   1654 │   │   │   │   super().invoke(ctx)                                                       │
│   1655 │   │   │   │   sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)                    │
│   1656 │   │   │   │   with sub_ctx:                                                             │
│ ❱ 1657 │   │   │   │   │   return _process_result(sub_ctx.command.invoke(sub_ctx))               │
│   1658 │   │                                                                                     │
│   1659 │   │   # In chain mode we create the contexts step by step, but after the                │
│   1660 │   │   # base command has been invoked.  Because at that point we do not                 │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:1657 in invoke   │
│                                                                                                  │
│   1654 │   │   │   │   super().invoke(ctx)                                                       │
│   1655 │   │   │   │   sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)                    │
│   1656 │   │   │   │   with sub_ctx:                                                             │
│ ❱ 1657 │   │   │   │   │   return _process_result(sub_ctx.command.invoke(sub_ctx))               │
│   1658 │   │                                                                                     │
│   1659 │   │   # In chain mode we create the contexts step by step, but after the                │
│   1660 │   │   # base command has been invoked.  Because at that point we do not                 │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:1657 in invoke   │
│                                                                                                  │
│   1654 │   │   │   │   super().invoke(ctx)                                                       │
│   1655 │   │   │   │   sub_ctx = cmd.make_context(cmd_name, args, parent=ctx)                    │
│   1656 │   │   │   │   with sub_ctx:                                                             │
│ ❱ 1657 │   │   │   │   │   return _process_result(sub_ctx.command.invoke(sub_ctx))               │
│   1658 │   │                                                                                     │
│   1659 │   │   # In chain mode we create the contexts step by step, but after the                │
│   1660 │   │   # base command has been invoked.  Because at that point we do not                 │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:1404 in invoke   │
│                                                                                                  │
│   1401 │   │   │   echo(style(message, fg="red"), err=True)                                      │
│   1402 │   │                                                                                     │
│   1403 │   │   if self.callback is not None:                                                     │
│ ❱ 1404 │   │   │   return ctx.invoke(self.callback, **ctx.params)                                │
│   1405 │                                                                                         │
│   1406 │   def shell_complete(self, ctx: Context, incomplete: str) -> t.List["CompletionItem"]:  │
│   1407 │   │   """Return a list of completions for the incomplete value. Looks                   │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:760 in invoke    │
│                                                                                                  │
│    757 │   │                                                                                     │
│    758 │   │   with augment_usage_errors(__self):                                                │
│    759 │   │   │   with ctx:                                                                     │
│ ❱  760 │   │   │   │   return __callback(*args, **kwargs)                                        │
│    761 │                                                                                         │
│    762 │   def forward(                                                                          │
│    763 │   │   __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any  # noqa: B902             │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/decorators.py:84 in      │
│ new_func                                                                                         │
│                                                                                                  │
│    81 │   │   │   │   │   " existing."                                                           │
│    82 │   │   │   │   )                                                                          │
│    83 │   │   │                                                                                  │
│ ❱  84 │   │   │   return ctx.invoke(f, obj, *args, **kwargs)                                     │
│    85 │   │                                                                                      │
│    86 │   │   return update_wrapper(t.cast(F, new_func), f)                                      │
│    87                                                                                            │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/core.py:760 in invoke    │
│                                                                                                  │
│    757 │   │                                                                                     │
│    758 │   │   with augment_usage_errors(__self):                                                │
│    759 │   │   │   with ctx:                                                                     │
│ ❱  760 │   │   │   │   return __callback(*args, **kwargs)                                        │
│    761 │                                                                                         │
│    762 │   def forward(                                                                          │
│    763 │   │   __self, __cmd: "Command", *args: t.Any, **kwargs: t.Any  # noqa: B902             │
│                                                                                                  │
│ /Users/fschulz/dev/learn-zenml/.venv/lib/python3.10/site-packages/click/decorators.py:26 in      │
│ new_func                                                                                         │
│                                                                                                  │
│    23 │   """                                                                                    │
│    24 │                                                                                          │
│    25 │   def new_func(*args, **kwargs):  # type: ignore                                         │
│ ❱  26 │   │   return f(get_current_context(), *args, **kwargs)                                   │
│    27 │                                                                                          │
│    28 │   return update_wrapper(t.cast(F, new_func), f)                                          │
│    29                                                                                            │
╰──────────────────────────────────────────────────────────────────────────────────────────────────╯
TypeError: destroy() got multiple values for argument 'stack_recipe_name'
```


### Code of Conduct

- [X] I agree to follow this project's Code of Conduct


Discussion:

Resolving patch:
diff --git a/src/zenml/cli/stack_recipes.py b/src/zenml/cli/stack_recipes.py
--- a/src/zenml/cli/stack_recipes.py
+++ b/src/zenml/cli/stack_recipes.py
@@ -1080,7 +1080,6 @@ def zen_server_exists() -> bool:
     help="Relative path at which you want to install the stack_recipe(s)",
 )
 @pass_git_stack_recipes_handler
-@click.pass_context
 def destroy(
     git_stack_recipes_handler: GitStackRecipesHandler,
     stack_recipe_name: str,


Test patch: