snowflake-cli-labs 2.8.0rc1__py3-none-any.whl → 3.0.0__py3-none-any.whl

snowflake/cli/{plugins → _plugins}/cortex/manager.py

@@ -19,17 +19,17 @@ import logging
 from typing import Callable, Optional
 
 from click import ClickException
-from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.api.sql_execution import SqlExecutionMixin
-from snowflake.cli.plugins.cortex.types import (
+from snowflake.cli._plugins.cortex.types import (
     Language,
     Model,
     Question,
     SourceDocument,
     Text,
 )
+from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
+from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.secure_path import SecurePath
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import DictCursor
 

snowflake/cli/{plugins → _plugins}/cortex/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.cortex import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.cortex import commands
 
 
 @plugin_hook_impl

snowflake/cli/{plugins → _plugins}/git/commands.py

@@ -18,10 +18,17 @@ import itertools
 import logging
 from os import path
 from pathlib import Path
-from typing import List, Optional
+from typing import Dict, List, Optional
 
 import typer
 from click import ClickException
+from snowflake.cli._plugins.git.manager import GitManager
+from snowflake.cli._plugins.object.command_aliases import (
+    add_object_command_aliases,
+    scope_option,
+)
+from snowflake.cli._plugins.object.manager import ObjectManager
+from snowflake.cli.api.commands.common import OnErrorType
 from snowflake.cli.api.commands.flags import (
     ExecuteVariablesOption,
     OnErrorOption,
@@ -34,13 +41,7 @@ from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.output.types import CollectionResult, CommandResult, QueryResult
 from snowflake.cli.api.utils.path_utils import is_stage_path
-from snowflake.cli.plugins.git.manager import GitManager
-from snowflake.cli.plugins.object.command_aliases import (
-    add_object_command_aliases,
-    scope_option,
-)
-from snowflake.cli.plugins.object.manager import ObjectManager
-from snowflake.cli.plugins.stage.manager import OnErrorType
+from snowflake.connector import DictCursor
 
 app = SnowTyperFactory(
     name="git",
@@ -71,6 +72,7 @@ RepoPathArgument = typer.Argument(
         " For example: @my_repo/branches/main/"
     ),
     callback=_repo_path_argument_callback,
+    show_default=False,
 )
 add_object_command_aliases(
     app=app,
@@ -82,10 +84,12 @@ add_object_command_aliases(
     scope_option=scope_option(help_example="`list --in database my_db`"),
 )
 
+from snowflake.cli.api.identifiers import FQN
+
 
-def _assure_repository_does_not_exist(om: ObjectManager, repository_name: str) -> None:
+def _assure_repository_does_not_exist(om: ObjectManager, repository_name: FQN) -> None:
     if om.object_exists(
-        object_type=ObjectType.GIT_REPOSITORY.value.cli_name, name=repository_name
+        object_type=ObjectType.GIT_REPOSITORY.value.cli_name, fqn=repository_name
     ):
         raise ClickException(f"Repository '{repository_name}' already exists")
 
@@ -95,14 +99,34 @@ def _validate_origin_url(url: str) -> None:
         raise ClickException("Url address should start with 'https'")
 
 
+def _unique_new_object_name(
+    om: ObjectManager, object_type: ObjectType, proposed_fqn: FQN
+) -> str:
+    existing_objects: List[Dict] = om.show(
+        object_type=object_type.value.cli_name,
+        like=f"{proposed_fqn.name}%",
+        cursor_class=DictCursor,
+    ).fetchall()
+    existing_names = set(o["name"].upper() for o in existing_objects)
+
+    result = proposed_fqn.name
+    i = 1
+    while result.upper() in existing_names:
+        result = proposed_fqn.name + str(i)
+        i += 1
+    return result
+
+
 @app.command("setup", requires_connection=True)
 def setup(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     **options,
 ) -> CommandResult:
     """
     Sets up a git repository object.
 
+    ## Usage notes
+
     You will be prompted for:
 
     * url - address of repository to be used for git clone operation
@@ -123,12 +147,29 @@ def setup(
     should_create_secret = False
     secret_name = None
     if secret_needed:
-        secret_name = f"{repository_name}_secret"
-        secret_name = typer.prompt(
-            "Secret identifier (will be created if not exists)", default=secret_name
+        default_secret_name = (
+            FQN.from_string(f"{repository_name.name}_secret")
+            .set_schema(repository_name.schema)
+            .set_database(repository_name.database)
+        )
+        default_secret_name.set_name(
+            _unique_new_object_name(
+                om, object_type=ObjectType.SECRET, proposed_fqn=default_secret_name
+            ),
         )
+        secret_name = FQN.from_string(
+            typer.prompt(
+                "Secret identifier (will be created if not exists)",
+                default=default_secret_name.name,
+            )
+        )
+        if not secret_name.database:
+            secret_name.set_database(repository_name.database)
+        if not secret_name.schema:
+            secret_name.set_schema(repository_name.schema)
+
         if om.object_exists(
-            object_type=ObjectType.SECRET.value.cli_name, name=secret_name
+            object_type=ObjectType.SECRET.value.cli_name, fqn=secret_name
         ):
             cli_console.step(f"Using existing secret '{secret_name}'")
         else:
@@ -137,10 +178,17 @@ def setup(
             secret_username = typer.prompt("username")
             secret_password = typer.prompt("password/token", hide_input=True)
 
-    api_integration = f"{repository_name}_api_integration"
-    api_integration = typer.prompt(
-        "API integration identifier (will be created if not exists)",
-        default=api_integration,
+    # API integration is an account-level object
+    api_integration = FQN.from_string(f"{repository_name.name}_api_integration")
+    api_integration.set_name(
+        typer.prompt(
+            "API integration identifier (will be created if not exists)",
+            default=_unique_new_object_name(
+                om,
+                object_type=ObjectType.INTEGRATION,
+                proposed_fqn=api_integration,
+            ),
+        )
     )
 
     if should_create_secret:
@@ -150,7 +198,7 @@ def setup(
         cli_console.step(f"Secret '{secret_name}' successfully created.")
 
     if not om.object_exists(
-        object_type=ObjectType.INTEGRATION.value.cli_name, name=api_integration
+        object_type=ObjectType.INTEGRATION.value.cli_name, fqn=api_integration
     ):
         manager.create_api_integration(
             name=api_integration,
@@ -177,7 +225,7 @@ def setup(
     requires_connection=True,
 )
 def list_branches(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     like=like_option(
         help_example='`list-branches --like "%_test"` lists all branches that end with "_test"'
     ),
@@ -186,7 +234,9 @@ def list_branches(
     """
     List all branches in the repository.
     """
-    return QueryResult(GitManager().show_branches(repo_name=repository_name, like=like))
+    return QueryResult(
+        GitManager().show_branches(repo_name=repository_name.identifier, like=like)
+    )
 
 
 @app.command(
@@ -194,7 +244,7 @@ def list_branches(
     requires_connection=True,
 )
 def list_tags(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     like=like_option(
         help_example='`list-tags --like "v2.0%"` lists all tags that start with "v2.0"'
     ),
@@ -203,7 +253,9 @@ def list_tags(
     """
     List all tags in the repository.
     """
-    return QueryResult(GitManager().show_tags(repo_name=repository_name, like=like))
+    return QueryResult(
+        GitManager().show_tags(repo_name=repository_name.identifier, like=like)
+    )
 
 
 @app.command(
@@ -228,13 +280,13 @@ def list_files(
     requires_connection=True,
 )
 def fetch(
-    repository_name: str = RepoNameArgument,
+    repository_name: FQN = RepoNameArgument,
     **options,
 ) -> CommandResult:
     """
     Fetch changes from origin to Snowflake repository.
     """
-    return QueryResult(GitManager().fetch(repo_name=repository_name))
+    return QueryResult(GitManager().fetch(fqn=repository_name))
 
 
 @app.command(
@@ -245,6 +297,7 @@ def copy(
     repository_path: str = RepoPathArgument,
     destination_path: str = typer.Argument(
         help="Target path for copy operation. Should be a path to a directory on remote stage or local file system.",
+        show_default=False,
     ),
     parallel: int = typer.Option(
         4,

snowflake/cli/{plugins → _plugins}/git/manager.py

@@ -14,43 +14,64 @@
 
 from __future__ import annotations
 
-from pathlib import Path
+from pathlib import Path, PurePosixPath
 from textwrap import dedent
 from typing import List
 
-from snowflake.cli.plugins.stage.manager import (
+from click import UsageError
+from snowflake.cli._plugins.stage.manager import (
     USER_STAGE_PREFIX,
     StageManager,
     StagePathParts,
     UserStagePathParts,
 )
+from snowflake.cli.api.identifiers import FQN
 from snowflake.connector.cursor import SnowflakeCursor
 
+# Replace magic numbers with constants
+OMIT_FIRST = slice(1, None)
+OMIT_STAGE = slice(3, None)
+OMIT_STAGE_IN_NEW_LIST_FILES = slice(2, None)
+ONLY_STAGE = slice(3)
+
 
 class GitStagePathParts(StagePathParts):
     def __init__(self, stage_path: str):
         self.stage = GitManager.get_stage_from_path(stage_path)
-        stage_path_parts = Path(stage_path).parts
+        stage_path_parts = GitManager.split_git_path(stage_path)
         git_repo_name = stage_path_parts[0].split(".")[-1]
         if git_repo_name.startswith("@"):
-            git_repo_name = git_repo_name[1:]
+            git_repo_name = git_repo_name[OMIT_FIRST]
         self.stage_name = "/".join([git_repo_name, *stage_path_parts[1:3], ""])
-        self.directory = "/".join(stage_path_parts[3:])
+        self.directory = "/".join(stage_path_parts[OMIT_STAGE])
         self.is_directory = True if stage_path.endswith("/") else False
 
     @property
     def path(self) -> str:
-        return (
-            f"{self.stage_name}{self.directory}"
-            if self.stage_name.endswith("/")
-            else f"{self.stage_name}/{self.directory}"
-        )
+        return f"{self.stage_name.rstrip('/')}/{self.directory}"
 
-    def add_stage_prefix(self, file_path: str) -> str:
+    @classmethod
+    def get_directory(cls, stage_path: str) -> str:
+        git_path_parts = GitManager.split_git_path(stage_path)
+        # New file list does not have a stage name at the beginning
+        if stage_path.startswith("/"):
+            return "/".join(git_path_parts[OMIT_STAGE_IN_NEW_LIST_FILES])
+        else:
+            return "/".join(git_path_parts[OMIT_STAGE])
+
+    @property
+    def full_path(self) -> str:
+        return f"{self.stage.rstrip('/')}/{self.directory}"
+
+    def replace_stage_prefix(self, file_path: str) -> str:
         stage = Path(self.stage).parts[0]
-        file_path_without_prefix = Path(file_path).parts[1:]
+        file_path_without_prefix = Path(file_path).parts[OMIT_FIRST]
         return f"{stage}/{'/'.join(file_path_without_prefix)}"
 
+    def add_stage_prefix(self, file_path: str) -> str:
+        stage = self.stage.rstrip("/")
+        return f"{stage}/{file_path.lstrip('/')}"
+
     def get_directory_from_file_path(self, file_path: str) -> List[str]:
         stage_path_length = len(Path(self.directory).parts)
         return list(Path(file_path).parts[3 + stage_path_length : -1])
@@ -63,15 +84,15 @@ class GitManager(StageManager):
     def show_tags(self, repo_name: str, like: str) -> SnowflakeCursor:
         return self._execute_query(f"show git tags like '{like}' in {repo_name}")
 
-    def fetch(self, repo_name: str) -> SnowflakeCursor:
-        return self._execute_query(f"alter git repository {repo_name} fetch")
+    def fetch(self, fqn: FQN) -> SnowflakeCursor:
+        return self._execute_query(f"alter git repository {fqn} fetch")
 
     def create(
-        self, repo_name: str, api_integration: str, url: str, secret: str
+        self, repo_name: FQN, api_integration: str, url: str, secret: str
     ) -> SnowflakeCursor:
         query = dedent(
             f"""
-            create git repository {repo_name}
+            create git repository {repo_name.sql_identifier}
             api_integration = {api_integration}
             origin = '{url}'
             """
@@ -86,7 +107,8 @@ class GitManager(StageManager):
         Returns stage name from potential path on stage. For example
         repo/branches/main/foo/bar -> repo/branches/main/
         """
-        return f"{'/'.join(Path(path).parts[0:3])}/"
+        path_parts = GitManager.split_git_path(path)
+        return f"{'/'.join(path_parts[ONLY_STAGE])}/"
 
     @staticmethod
     def _stage_path_part_factory(stage_path: str) -> StagePathParts:
@@ -94,3 +116,36 @@ class GitManager(StageManager):
         if stage_path.startswith(USER_STAGE_PREFIX):
             return UserStagePathParts(stage_path)
         return GitStagePathParts(stage_path)
+
+    @staticmethod
+    def split_git_path(path: str):
+        # Check if path contains quotes and split it accordingly
+        if '/"' in path and '"/' in path:
+            if path.count('"') > 2:
+                raise UsageError(
+                    f'Invalid string {path}, too much " in path, expected 2.'
+                )
+
+            path_parts = path.split('"')
+            before_quoted_part = GitManager._split_path_without_empty_parts(
+                path_parts[0]
+            )
+
+            if path_parts[2] == "/":
+                after_quoted_part = []
+            else:
+                after_quoted_part = GitManager._split_path_without_empty_parts(
+                    path_parts[2]
+                )
+
+            return [
+                *before_quoted_part,
+                f'"{path_parts[1]}"',
+                *after_quoted_part,
+            ]
+        else:
+            return GitManager._split_path_without_empty_parts(path)
+
+    @staticmethod
+    def _split_path_without_empty_parts(path: str):
+        return [e for e in PurePosixPath(path).parts if e != "/"]

snowflake/cli/{plugins → _plugins}/git/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.git import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.git import commands
 
 
 @plugin_hook_impl

snowflake/cli/_plugins/helpers/commands.py

@@ -0,0 +1,90 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# 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
+#
+# http://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.
+
+from __future__ import annotations
+
+import typer
+import yaml
+from click import ClickException
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.output.types import MessageResult
+from snowflake.cli.api.project.definition_conversion import (
+    convert_project_definition_to_v2,
+)
+from snowflake.cli.api.project.definition_manager import DefinitionManager
+from snowflake.cli.api.secure_path import SecurePath
+
+app = SnowTyperFactory(
+    name="helpers",
+    help="Helper commands.",
+)
+
+
+@app.command()
+def v1_to_v2(
+    accept_templates: bool = typer.Option(
+        False, "-t", "--accept-templates", help="Allows the migration of templates."
+    ),
+    migrate_local_yml: (bool | None) = typer.Option(
+        None,
+        "-l",
+        "--migrate-local-overrides/--no-migrate-local-overrides",
+        help=(
+            "Merge values in snowflake.local.yml into the main project definition. "
+            "The snowflake.local.yml file will not be migrated, "
+            "instead its values will be reflected in the output snowflake.yml file. "
+            "If unset and snowflake.local.yml is present, an error will be raised."
+        ),
+        show_default=False,
+    ),
+    **options,
+):
+    """Migrates the Snowpark, Streamlit, and Native App project definition files from V1 to V2."""
+    manager = DefinitionManager()
+    local_yml_path = manager.project_root / "snowflake.local.yml"
+    has_local_yml = local_yml_path in manager.project_config_paths
+    if has_local_yml:
+        if migrate_local_yml is None:
+            raise ClickException(
+                "snowflake.local.yml file detected, "
+                "please specify --migrate-local-overrides to include "
+                "or --no-migrate-local-overrides to exclude its values."
+            )
+        if not migrate_local_yml:
+            # If we don't want the local file,
+            # remove it from the list of paths to load
+            manager.project_config_paths.remove(local_yml_path)
+
+    pd = manager.unrendered_project_definition
+
+    if pd.meets_version_requirement("2"):
+        return MessageResult("Project definition is already at version 2.")
+
+    pd_v2 = convert_project_definition_to_v2(
+        manager.project_root, pd, accept_templates, manager.template_context
+    )
+
+    SecurePath("snowflake.yml").rename("snowflake_V1.yml")
+    if has_local_yml:
+        SecurePath("snowflake.local.yml").rename("snowflake_V1.local.yml")
+    with open("snowflake.yml", "w") as file:
+        yaml.dump(
+            pd_v2.model_dump(
+                exclude_unset=True, exclude_none=True, mode="json", by_alias=True
+            ),
+            file,
+            sort_keys=False,
+            width=float("inf"),  # Don't break lines
+        )
+    return MessageResult("Project definition migrated to version 2.")

snowflake/cli/{plugins/notebook → _plugins/helpers}/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.helpers import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.notebook import commands
 
 
 @plugin_hook_impl

snowflake/cli/{plugins → _plugins}/init/commands.py

@@ -23,10 +23,10 @@ from click import ClickException
 from snowflake.cli.__about__ import VERSION
 from snowflake.cli.api.commands.flags import (
     NoInteractiveOption,
-    parse_key_value_variables,
     variables_option,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.commands.utils import parse_key_value_variables
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.exceptions import InvalidTemplate
 from snowflake.cli.api.output.types import (
@@ -68,7 +68,8 @@ TemplateOption = typer.Option(
     show_default=False,
 )
 SourceOption = typer.Option(
-    default=DEFAULT_SOURCE,
+    DEFAULT_SOURCE,
+    "--template-source",
     help=f"local path to template directory or URL to git repository with templates.",
 )
 VariablesOption = variables_option(
@@ -106,7 +107,7 @@ def _fetch_remote_template(
     from git import rmtree as git_rmtree
 
     # TODO: during nativeapp refactor get rid of this dependency
-    from snowflake.cli.plugins.nativeapp.utils import shallow_git_clone
+    from snowflake.cli._plugins.nativeapp.utils import shallow_git_clone
 
     log.info("Downloading remote template from %s", url)
     try:
@@ -132,13 +133,13 @@ def _fetch_remote_template(
     return template_root
 
 
-def _read_template_metadata(template_root: SecurePath) -> Template:
+def _read_template_metadata(template_root: SecurePath, args_error_msg: str) -> Template:
     """Parse template.yml file."""
     template_metadata_path = template_root / TEMPLATE_METADATA_FILE_NAME
     log.debug("Reading template metadata from %s", template_metadata_path.path)
     if not template_metadata_path.exists():
         raise InvalidTemplate(
-            f"Template does not have {TEMPLATE_METADATA_FILE_NAME} file."
+            f"File {TEMPLATE_METADATA_FILE_NAME} not found. {args_error_msg}"
         )
     with template_metadata_path.open(read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as fd:
         yaml_contents = yaml.safe_load(fd) or {}
@@ -203,6 +204,7 @@ def init(
     is_remote = any(
         template_source.startswith(prefix) for prefix in ["git@", "http://", "https://"]  # type: ignore
     )
+    args_error_msg = f"Check whether {TemplateOption.param_decls[0]} and {SourceOption.param_decls[0]} arguments are correct."
 
     # copy/download template into tmpdir, so it is going to be removed in case command ends with an error
     with SecurePath.temporary_directory() as tmpdir:
@@ -217,7 +219,9 @@ def init(
                 destination=tmpdir,
             )
 
-        template_metadata = _read_template_metadata(template_root)
+        template_metadata = _read_template_metadata(
+            template_root, args_error_msg=args_error_msg
+        )
         if template_metadata.minimum_cli_version:
             _validate_cli_version(template_metadata.minimum_cli_version)
 

snowflake/cli/{plugins → _plugins}/init/plugin_spec.py

@@ -12,13 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from snowflake.cli._plugins.init import commands
 from snowflake.cli.api.plugins.command import (
     SNOWCLI_ROOT_COMMAND_PATH,
     CommandSpec,
     CommandType,
     plugin_hook_impl,
 )
-from snowflake.cli.plugins.init import commands
 
 
 @plugin_hook_impl

snowflake/cli/{plugins → _plugins}/nativeapp/artifacts.py

@@ -22,7 +22,8 @@ from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional, Tupl
 
 from click.exceptions import ClickException
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
-from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
+from snowflake.cli.api.project.util import to_identifier
 from snowflake.cli.api.secure_path import SecurePath
 from yaml import safe_load
 
@@ -199,6 +200,12 @@ class _ArtifactPathMap:
         """
         return self.__src_to_dest.keys()
 
+    def is_empty(self) -> bool:
+        """
+        Returns True if this map has no source-destination mappings.
+        """
+        return len(self.__src_dest_pairs) == 0
+
     def __iter__(self) -> Iterator[Tuple[Path, Path]]:
         """
         Returns all (source, destination) pairs known to this map, in insertion order.
@@ -240,6 +247,9 @@ class BundleMap:
         self._deploy_root: Path = resolve_without_follow(deploy_root)
         self._artifact_map = _ArtifactPathMap(project_root=self._project_root)
 
+    def is_empty(self) -> bool:
+        return self._artifact_map.is_empty()
+
     def deploy_root(self) -> Path:
         return self._deploy_root
 
@@ -658,6 +668,11 @@ def build_bundle(
     for artifact in artifacts:
         bundle_map.add(artifact)
 
+    if bundle_map.is_empty():
+        raise ArtifactError(
+            "No artifacts mapping found in project definition, nothing to do."
+        )
+
     for (absolute_src, absolute_dest) in bundle_map.all_mappings(
         absolute=True, expand_directories=False
     ):
@@ -720,23 +735,23 @@ def find_setup_script_file(deploy_root: Path) -> Path:
 
 def find_version_info_in_manifest_file(
     deploy_root: Path,
-) -> Tuple[Optional[str], Optional[str]]:
+) -> Tuple[Optional[str], Optional[int]]:
     """
     Find version and patch, if available, in the manifest.yml file.
     """
-    version_field = "version"
     name_field = "name"
     patch_field = "patch"
 
     manifest_content = find_and_read_manifest_file(deploy_root=deploy_root)
 
     version_name: Optional[str] = None
-    patch_name: Optional[str] = None
+    patch_number: Optional[int] = None
 
-    if version_field in manifest_content:
-        version_info = manifest_content[version_field]
-        version_name = version_info[name_field]
+    version_info = manifest_content.get("version", None)
+    if version_info:
+        if name_field in version_info:
+            version_name = to_identifier(str(version_info[name_field]))
         if patch_field in version_info:
-            patch_name = version_info[patch_field]
+            patch_number = int(version_info[patch_field])
 
-    return version_name, patch_name
+    return version_name, patch_number