snowflake-cli 2.8.2__py3-none-any.whl

snowflake/cli/plugins/stage/md5.py

@@ -0,0 +1,160 @@
+# 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 hashlib
+import logging
+import math
+import os.path
+import re
+from pathlib import Path
+from typing import List, Tuple
+
+from click.exceptions import ClickException
+from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.connector.constants import S3_CHUNK_SIZE, S3_MAX_PARTS, S3_MIN_PART_SIZE
+
+ONE_MEGABYTE = 1024**2
+READ_BUFFER_BYTES = 64 * 1024
+MD5SUM_REGEX = r"^[A-Fa-f0-9]{32}$"
+MULTIPART_MD5SUM_REGEX = r"^([A-Fa-f0-9]{32})-(\d+)$"
+
+log = logging.getLogger(__name__)
+
+
+class UnknownMD5FormatError(ClickException):
+    def __init__(self, md5: str):
+        super().__init__(f"Unknown md5 format: {md5}")
+
+
+def is_md5sum(checksum: str) -> bool:
+    """
+    Could the provided hexadecimal checksum represent a valid md5sum?
+    """
+    return re.match(MD5SUM_REGEX, checksum) is not None
+
+
+def parse_multipart_md5sum(checksum: str) -> Tuple[str, int] | None:
+    """
+    Does this represent a multi-part md5sum (i.e. "<md5>-<n>")?
+    If so, returns the tuple (md5, n), otherwise None.
+    """
+    multipart_md5 = re.match(MULTIPART_MD5SUM_REGEX, checksum)
+    if multipart_md5:
+        return (multipart_md5.group(1), int(multipart_md5.group(2)))
+    return None
+
+
+def compute_md5sum(file: Path, chunk_size: int | None = None) -> str:
+    """
+    Returns a hexadecimal checksum for the file located at the given path.
+    If chunk_size is given, computes a multi-part md5sum.
+    """
+    if not file.is_file():
+        raise ValueError(
+            "The provided file does not exist or not a (symlink to a) regular file"
+        )
+
+    # If the stage uses SNOWFLAKE_FULL encryption, this will fail to provide
+    # a matching md5sum, even when the underlying file is the same, as we do
+    # not have access to the encrypted file under checksum.
+
+    file_size = os.path.getsize(file)
+    if file_size == 0:
+        # simple md5 with no content
+        return hashlib.md5().hexdigest()
+
+    with SecurePath(file).open("rb", read_file_limit_mb=UNLIMITED) as f:
+        md5s: List[hashlib._Hash] = []  # noqa: SLF001
+        hasher = hashlib.md5()
+
+        remains = file_size
+        remains_in_chunk: int = min(chunk_size, remains) if chunk_size else remains
+        while remains > 0:
+            sz = min(READ_BUFFER_BYTES, remains_in_chunk)
+            buf = f.read(sz)
+            hasher.update(buf)
+            remains_in_chunk -= sz
+            remains -= sz
+            if remains_in_chunk == 0:
+                if not chunk_size:
+                    # simple md5; only one chunk processed
+                    return hasher.hexdigest()
+                else:
+                    # push the hash of this chunk + reset
+                    md5s.append(hasher)
+                    hasher = hashlib.md5()
+                    remains_in_chunk = min(chunk_size, remains)
+
+        # multi-part hash (e.g. aws)
+        digests = b"".join(m.digest() for m in md5s)
+        digests_md5 = hashlib.md5(digests)
+        return f"{digests_md5.hexdigest()}-{len(md5s)}"
+
+
+def file_matches_md5sum(local_file: Path, remote_md5: str | None) -> bool:
+    """
+    Try a few different md5sums to determine if a local file is identical
+    to a file that has a given remote md5sum.
+
+    Handles the multi-part md5sums generated by e.g. AWS S3, using values
+    from the python connector to make educated guesses on chunk size.
+
+    Assumes that upload time would dominate local hashing time.
+    """
+    if not remote_md5:
+        # no hash available
+        return False
+
+    if is_md5sum(remote_md5):
+        # regular hash
+        return compute_md5sum(local_file) == remote_md5
+
+    if md5_and_chunks := parse_multipart_md5sum(remote_md5):
+        # multi-part hash (e.g. aws)
+        (_, num_chunks) = md5_and_chunks
+        file_size = os.path.getsize(local_file)
+
+        # If this file uses the maximum number of parts supported by the cloud backend,
+        # the chunk size is likely not a clean multiple of a megabyte. Try reverse engineering
+        # from the file size first, then fall back to the usual detection method.
+        # At time of writing this logic would trigger for files >= 80GiB (python connector)
+        if num_chunks == S3_MAX_PARTS:
+            chunk_size = max(math.ceil(file_size / S3_MAX_PARTS), S3_MIN_PART_SIZE)
+            if compute_md5sum(local_file, chunk_size) == remote_md5:
+                return True
+
+        # Estimates the chunk size the multi-part file must have been uploaded with
+        # by trying chunk sizes that give the most evenly-sized chunks.
+        #
+        # First we'll try the chunk size that's a multiple of S3_CHUNK_SIZE (8mb) from
+        # the python connector that results in num_chunks, then we'll do the same with
+        # a smaller granularity (1mb) that is used by default in some AWS multi-part
+        # upload implementations.
+        #
+        # We're working backwards from num_chunks here because it's the only value we know.
+        for chunk_size_alignment in [S3_CHUNK_SIZE, ONE_MEGABYTE]:
+            # +1 because we need at least one chunk when file_size < num_chunks * chunk_size_alignment
+            # -1 because we don't want to add an extra chunk when file_size is an exact multiple of num_chunks * chunk_size_alignment
+            multiplier = 1 + ((file_size - 1) // (num_chunks * chunk_size_alignment))
+            chunk_size = multiplier * chunk_size_alignment
+            if compute_md5sum(local_file, chunk_size) == remote_md5:
+                return True
+
+        # we were unable to figure out the chunk size, or the files are different
+        log.debug("multi-part md5: %s != %s", remote_md5, local_file)
+        return False
+
+    raise UnknownMD5FormatError(remote_md5)

snowflake/cli/plugins/stage/plugin_spec.py

@@ -0,0 +1,30 @@
+# 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 snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+from snowflake.cli.plugins.stage import commands
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/plugins/streamlit/__init__.py

@@ -0,0 +1,13 @@
+# 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.

snowflake/cli/plugins/streamlit/commands.py

@@ -0,0 +1,179 @@
+# 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 logging
+from pathlib import Path
+
+import click
+import typer
+from click import ClickException
+from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.commands.decorators import (
+    with_experimental_behaviour,
+    with_project_definition,
+)
+from snowflake.cli.api.commands.flags import (
+    ReplaceOption,
+    identifier_argument,
+    like_option,
+)
+from snowflake.cli.api.commands.project_initialisation import add_init_command
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    MessageResult,
+    SingleQueryResult,
+)
+from snowflake.cli.api.project.project_verification import assert_project_type
+from snowflake.cli.api.project.schemas.streamlit.streamlit import Streamlit
+from snowflake.cli.plugins.object.command_aliases import (
+    add_object_command_aliases,
+    scope_option,
+)
+from snowflake.cli.plugins.streamlit.manager import StreamlitManager
+
+app = SnowTyperFactory(
+    name="streamlit",
+    help="Manages a Streamlit app in Snowflake.",
+)
+log = logging.getLogger(__name__)
+
+StreamlitNameArgument = identifier_argument(
+    sf_object="Streamlit app", example="my_streamlit"
+)
+OpenOption = typer.Option(
+    False,
+    "--open",
+    help="Whether to open the Streamlit app in a browser.",
+    is_flag=True,
+)
+
+add_init_command(
+    app,
+    project_type="Streamlit",
+    template="default_streamlit",
+    help_message="Name of the Streamlit app project directory you want to create. Defaults to `example_streamlit`.",
+)
+
+add_object_command_aliases(
+    app=app,
+    object_type=ObjectType.STREAMLIT,
+    name_argument=StreamlitNameArgument,
+    like_option=like_option(
+        help_example='`list --like "my%"` lists all streamlit apps that begin with “my”'
+    ),
+    scope_option=scope_option(help_example="`list --in database my_db`"),
+)
+
+
+@app.command("share", requires_connection=True)
+def streamlit_share(
+    name: FQN = StreamlitNameArgument,
+    to_role: str = typer.Argument(
+        ..., help="Role with which to share the Streamlit app."
+    ),
+    **options,
+) -> CommandResult:
+    """
+    Shares a Streamlit app with another role.
+    """
+    cursor = StreamlitManager().share(streamlit_name=name, to_role=to_role)
+    return SingleQueryResult(cursor)
+
+
+def _default_file_callback(param_name: str):
+    from click.core import ParameterSource  # type: ignore
+
+    def _check_file_exists_if_not_default(ctx: click.Context, value):
+        if (
+            ctx.get_parameter_source(param_name) != ParameterSource.DEFAULT  # type: ignore
+            and value
+            and not Path(value).exists()
+        ):
+            raise ClickException(f"Provided file {value} does not exist")
+        return Path(value)
+
+    return _check_file_exists_if_not_default
+
+
+@app.command("deploy", requires_connection=True)
+@with_project_definition()
+@with_experimental_behaviour()
+def streamlit_deploy(
+    replace: bool = ReplaceOption(
+        help="Replace the Streamlit app if it already exists."
+    ),
+    open_: bool = OpenOption,
+    **options,
+) -> CommandResult:
+    """
+    Deploys a Streamlit app defined in the project definition file (snowflake.yml). By default, the command uploads
+    environment.yml and any other pages or folders, if present. If you don’t specify a stage name, the `streamlit`
+    stage is used. If the specified stage does not exist, the command creates it.
+    """
+
+    assert_project_type("streamlit")
+
+    streamlit: Streamlit = cli_context.project_definition.streamlit
+    if not streamlit:
+        return MessageResult("No streamlit were specified in project definition.")
+
+    environment_file = streamlit.env_file
+    if environment_file and not Path(environment_file).exists():
+        raise ClickException(f"Provided file {environment_file} does not exist")
+    elif environment_file is None:
+        environment_file = "environment.yml"
+
+    pages_dir = streamlit.pages_dir
+    if pages_dir and not Path(pages_dir).exists():
+        raise ClickException(f"Provided file {pages_dir} does not exist")
+    elif pages_dir is None:
+        pages_dir = "pages"
+
+    streamlit_id = FQN.from_identifier_model(streamlit).using_context()
+
+    url = StreamlitManager().deploy(
+        streamlit_id=streamlit_id,
+        environment_file=Path(environment_file),
+        pages_dir=Path(pages_dir),
+        stage_name=streamlit.stage,
+        main_file=Path(streamlit.main_file),
+        replace=replace,
+        query_warehouse=streamlit.query_warehouse,
+        additional_source_files=streamlit.additional_source_files,
+        title=streamlit.title,
+        **options,
+    )
+
+    if open_:
+        typer.launch(url)
+
+    return MessageResult(f"Streamlit successfully deployed and available under {url}")
+
+
+@app.command("get-url", requires_connection=True)
+def get_url(
+    name: FQN = StreamlitNameArgument,
+    open_: bool = OpenOption,
+    **options,
+):
+    """Returns a URL to the specified Streamlit app"""
+    url = StreamlitManager().get_url(streamlit_name=name)
+    if open_:
+        typer.launch(url)
+    return MessageResult(url)

snowflake/cli/plugins/streamlit/manager.py

@@ -0,0 +1,222 @@
+# 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 logging
+import os
+from pathlib import Path
+from typing import List, Optional
+
+from snowflake.cli.api.commands.experimental_behaviour import (
+    experimental_behaviour_enabled,
+)
+from snowflake.cli.api.feature_flags import FeatureFlag
+from snowflake.cli.api.identifiers import FQN
+from snowflake.cli.api.sql_execution import SqlExecutionMixin
+from snowflake.cli.plugins.connection.util import (
+    MissingConnectionAccountError,
+    MissingConnectionRegionError,
+    make_snowsight_url,
+)
+from snowflake.cli.plugins.stage.manager import StageManager
+from snowflake.connector.cursor import SnowflakeCursor
+from snowflake.connector.errors import ProgrammingError
+
+log = logging.getLogger(__name__)
+
+
+class StreamlitManager(SqlExecutionMixin):
+    def share(self, streamlit_name: FQN, to_role: str) -> SnowflakeCursor:
+        return self._execute_query(
+            f"grant usage on streamlit {streamlit_name.sql_identifier} to role {to_role}"
+        )
+
+    def _put_streamlit_files(
+        self,
+        root_location: str,
+        main_file: Path,
+        environment_file: Optional[Path],
+        pages_dir: Optional[Path],
+        additional_source_files: Optional[List[Path]],
+    ):
+        stage_manager = StageManager()
+
+        stage_manager.put(main_file, root_location, 4, True)
+
+        if environment_file and environment_file.exists():
+            stage_manager.put(environment_file, root_location, 4, True)
+
+        if pages_dir and pages_dir.exists():
+            stage_manager.put(pages_dir / "*.py", f"{root_location}/pages", 4, True)
+
+        if additional_source_files:
+            for file in additional_source_files:
+                if os.sep in str(file):
+                    destination = f"{root_location}/{str(file.parent)}"
+                else:
+                    destination = root_location
+                stage_manager.put(file, destination, 4, True)
+
+    def _create_streamlit(
+        self,
+        streamlit_id: FQN,
+        main_file: Path,
+        replace: Optional[bool] = None,
+        experimental: Optional[bool] = None,
+        query_warehouse: Optional[str] = None,
+        from_stage_name: Optional[str] = None,
+        title: Optional[str] = None,
+    ):
+        query = []
+        if replace:
+            query.append(f"CREATE OR REPLACE STREAMLIT {streamlit_id.sql_identifier}")
+        elif experimental:
+            # For experimental behaviour, we need to use CREATE STREAMLIT IF NOT EXISTS
+            # for a streamlit app with an embedded stage
+            # because this is analogous to the behavior for non-experimental
+            # deploy which does CREATE STAGE IF NOT EXISTS
+            query.append(
+                f"CREATE STREAMLIT IF NOT EXISTS {streamlit_id.sql_identifier}"
+            )
+        else:
+            query.append(f"CREATE STREAMLIT {streamlit_id.sql_identifier}")
+
+        if from_stage_name:
+            query.append(f"ROOT_LOCATION = '{from_stage_name}'")
+
+        query.append(f"MAIN_FILE = '{main_file.name}'")
+
+        if query_warehouse:
+            query.append(f"QUERY_WAREHOUSE = {query_warehouse}")
+        if title:
+            query.append(f"TITLE = '{title}'")
+
+        self._execute_query("\n".join(query))
+
+    def deploy(
+        self,
+        streamlit_id: FQN,
+        main_file: Path,
+        environment_file: Optional[Path] = None,
+        pages_dir: Optional[Path] = None,
+        stage_name: Optional[str] = None,
+        query_warehouse: Optional[str] = None,
+        replace: Optional[bool] = False,
+        additional_source_files: Optional[List[Path]] = None,
+        title: Optional[str] = None,
+        **options,
+    ):
+        # for backwards compatibility - quoted stage path might be case-sensitive
+        # https://docs.snowflake.com/en/sql-reference/identifiers-syntax#double-quoted-identifiers
+        streamlit_name_for_root_location = streamlit_id.name
+        use_versioned_stage = FeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
+        if (
+            experimental_behaviour_enabled()
+            or FeatureFlag.ENABLE_STREAMLIT_EMBEDDED_STAGE.is_enabled()
+            or use_versioned_stage
+        ):
+            """
+            1. Create streamlit object
+            2. Upload files to embedded stage
+            """
+            # TODO: Support from_stage
+            # from_stage_stmt = f"FROM_STAGE = '{stage_name}'" if stage_name else ""
+            self._create_streamlit(
+                streamlit_id,
+                main_file,
+                replace=replace,
+                query_warehouse=query_warehouse,
+                experimental=True,
+                title=title,
+            )
+            try:
+                if use_versioned_stage:
+                    self._execute_query(
+                        f"ALTER STREAMLIT {streamlit_id.identifier} ADD LIVE VERSION FROM LAST"
+                    )
+                elif not FeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
+                    self._execute_query(
+                        f"ALTER streamlit {streamlit_id.identifier} CHECKOUT"
+                    )
+            except ProgrammingError as e:
+                # If an error is raised because a CHECKOUT has already occurred or a LIVE VERSION already exists, simply skip it and continue
+                if "Checkout already exists" in str(
+                    e
+                ) or "There is already a live version" in str(e):
+                    log.info("Checkout already exists, continuing")
+                else:
+                    raise
+
+            stage_path = streamlit_id.identifier
+            embedded_stage_name = f"snow://streamlit/{stage_path}"
+            if use_versioned_stage:
+                # "LIVE" is the only supported version for now, but this may change later.
+                root_location = f"{embedded_stage_name}/versions/live"
+            else:
+                root_location = f"{embedded_stage_name}/default_checkout"
+
+            self._put_streamlit_files(
+                root_location,
+                main_file,
+                environment_file,
+                pages_dir,
+                additional_source_files,
+            )
+        else:
+            """
+            1. Create stage
+            2. Upload files to created stage
+            3. Create streamlit from stage
+            """
+            stage_manager = StageManager()
+
+            stage_name = stage_name or "streamlit"
+            stage_name = FQN.from_string(stage_name).using_connection(self._conn)
+
+            stage_manager.create(fqn=stage_name)
+
+            root_location = stage_manager.get_standard_stage_prefix(
+                f"{stage_name}/{streamlit_name_for_root_location}"
+            )
+
+            self._put_streamlit_files(
+                root_location,
+                main_file,
+                environment_file,
+                pages_dir,
+                additional_source_files,
+            )
+
+            self._create_streamlit(
+                streamlit_id,
+                main_file,
+                replace=replace,
+                query_warehouse=query_warehouse,
+                from_stage_name=root_location,
+                experimental=False,
+                title=title,
+            )
+
+        return self.get_url(streamlit_name=streamlit_id)
+
+    def get_url(self, streamlit_name: FQN) -> str:
+        try:
+            fqn = streamlit_name.using_connection(self._conn)
+            return make_snowsight_url(
+                self._conn,
+                f"/#/streamlit-apps/{fqn.url_identifier}",
+            )
+        except (MissingConnectionRegionError, MissingConnectionAccountError) as e:
+            return "https://app.snowflake.com"

snowflake/cli/plugins/streamlit/plugin_spec.py

@@ -0,0 +1,30 @@
+# 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 snowflake.cli.api.plugins.command import (
+    SNOWCLI_ROOT_COMMAND_PATH,
+    CommandSpec,
+    CommandType,
+    plugin_hook_impl,
+)
+from snowflake.cli.plugins.streamlit import commands
+
+
+@plugin_hook_impl
+def command_spec():
+    return CommandSpec(
+        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
+        command_type=CommandType.COMMAND_GROUP,
+        typer_instance=commands.app.create_instance(),
+    )

snowflake/cli/plugins/workspace/__init__.py

@@ -0,0 +1,13 @@
+# 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.

snowflake/cli/plugins/workspace/commands.py

@@ -0,0 +1,35 @@
+# 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
+
+from snowflake.cli.api.commands.decorators import with_project_definition
+from snowflake.cli.api.commands.snow_typer import SnowTyper
+from snowflake.cli.api.output.types import MessageResult
+
+ws = SnowTyper(
+    name="ws",
+    hidden=True,
+    help="Deploy and interact with snowflake.yml-based entities.",
+)
+
+
+@ws.command(requires_connection=True)
+@with_project_definition()
+def validate(
+    **options,
+):
+    """Validates the project definition file."""
+    # If we get to this point, @with_project_definition() has already validated the PDF schema
+    return MessageResult("Project definition is valid.")