snowflake-cli 3.0.2__py3-none-any.whl → 3.1.0__py3-none-any.whl

snowflake/cli/api/commands/flags.py

@@ -33,6 +33,7 @@ from snowflake.cli.api.connections import ConnectionContext
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.stage_path import StagePath
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
 
@@ -83,7 +84,7 @@ ConnectionOption = typer.Option(
     "--connection",
     "-c",
     "--environment",
-    help=f"Name of the connection, as defined in your `config.toml`. Default: `default`.",
+    help=f"Name of the connection, as defined in your `config.toml` file. Default: `default`.",
     callback=_connection_callback("connection_name"),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
@@ -276,7 +277,7 @@ MfaPasscodeOption = typer.Option(
 EnableDiagOption = typer.Option(
     False,
     "--enable-diag",
-    help="Run python connector diagnostic test",
+    help="Run Python connector diagnostic test",
     callback=_connection_callback("enable_diag"),
     show_default=False,
     is_flag=True,
@@ -349,7 +350,7 @@ VerboseOption = typer.Option(
 DebugOption = typer.Option(
     False,
     "--debug",
-    help="Displays log entries for log levels `debug` and higher; debug logs contains additional information.",
+    help="Displays log entries for log levels `debug` and higher; debug logs contain additional information.",
     callback=_context_callback("enable_tracebacks"),
     is_flag=True,
     rich_help_panel=_CLI_BEHAVIOUR,
@@ -406,9 +407,9 @@ def variables_option(description: str):
 
 
 ExecuteVariablesOption = variables_option(
-    'Variables for the execution context. For example: `-D "<key>=<value>"`. '
-    "For SQL files variables are use to expand the template and any unknown variable will cause an error. "
-    "For Python files variables are used to update os.environ dictionary. Provided keys are capitalized to adhere to best practices."
+    'Variables for the execution context; for example: `-D "<key>=<value>"`. '
+    "For SQL files, variables are used to expand the template, and any unknown variable will cause an error (consider embedding quoting in the file)."
+    "For Python files, variables are used to update the os.environ dictionary. Provided keys are capitalized to adhere to best practices. "
     "In case of SQL files string values must be quoted in `''` (consider embedding quoting in the file).",
 )
 
@@ -473,6 +474,13 @@ class IdentifierStageType(click.ParamType):
         return FQN.from_stage(value)
 
 
+class IdentifierStagePathType(click.ParamType):
+    name = "TEXT"
+
+    def convert(self, value, param, ctx):
+        return StagePath.from_stage_str(value)
+
+
 def identifier_argument(
     sf_object: str,
     example: str,
@@ -481,7 +489,7 @@ def identifier_argument(
 ) -> typer.Argument:
     return typer.Argument(
         ...,
-        help=f"Identifier of the {sf_object}. For example: {example}",
+        help=f"Identifier of the {sf_object}; for example: {example}",
         show_default=False,
         click_type=click_type,
         callback=callback,
@@ -496,6 +504,14 @@ def identifier_stage_argument(
     )
 
 
+def identifier_stage_path_argument(
+    sf_object: str, example: str, callback: Callable | None = None
+) -> typer.Argument:
+    return identifier_argument(
+        sf_object, example, click_type=IdentifierStagePathType(), callback=callback
+    )
+
+
 def execution_identifier_argument(sf_object: str, example: str) -> typer.Argument:
     return typer.Argument(
         ...,

snowflake/cli/api/config.py

@@ -346,10 +346,13 @@ def _dump_config(conf_file_cache: Dict):
 
 
 def _check_default_config_files_permissions() -> None:
-    if CONNECTIONS_FILE.exists() and not file_permissions_are_strict(CONNECTIONS_FILE):
-        raise ConfigFileTooWidePermissionsError(CONNECTIONS_FILE)
-    if CONFIG_FILE.exists() and not file_permissions_are_strict(CONFIG_FILE):
-        raise ConfigFileTooWidePermissionsError(CONFIG_FILE)
+    if not IS_WINDOWS:
+        if CONNECTIONS_FILE.exists() and not file_permissions_are_strict(
+            CONNECTIONS_FILE
+        ):
+            raise ConfigFileTooWidePermissionsError(CONNECTIONS_FILE)
+        if CONFIG_FILE.exists() and not file_permissions_are_strict(CONFIG_FILE):
+            raise ConfigFileTooWidePermissionsError(CONFIG_FILE)
 
 
 from typing import Literal

snowflake/cli/api/connections.py

@@ -22,7 +22,7 @@ from dataclasses import asdict, dataclass, field, fields, replace
 from pathlib import Path
 from typing import Optional
 
-from snowflake.cli.api.config import get_default_connection_name
+from snowflake.cli.api.config import get_connection_dict, get_default_connection_name
 from snowflake.cli.api.exceptions import InvalidSchemaError
 from snowflake.connector import SnowflakeConnection
 from snowflake.connector.compat import IS_WINDOWS
@@ -79,6 +79,17 @@ class ConnectionContext:
                 raise KeyError(f"{key} is not a field of {self.__class__.__name__}")
             setattr(self, key, value)
 
+    def update_from_config(self) -> ConnectionContext:
+        connection_config = get_connection_dict(connection_name=self.connection_name)
+        if "private_key_path" in connection_config:
+            connection_config["private_key_file"] = connection_config[
+                "private_key_path"
+            ]
+            del connection_config["private_key_path"]
+
+        self.update(**connection_config)
+        return self
+
     def __repr__(self) -> str:
         """Minimal repr where None values have their keys omitted."""
         items = [f"{k}={repr(v)}" for (k, v) in self.present_values_as_dict().items()]

snowflake/cli/api/entities/common.py

@@ -1,7 +1,7 @@
 from enum import Enum
 from typing import Generic, Type, TypeVar, get_args
 
-from snowflake.cli._plugins.workspace.action_context import ActionContext
+from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
 from snowflake.cli.api.sql_execution import SqlExecutor
 
 
@@ -10,6 +10,7 @@ class EntityActions(str, Enum):
     DEPLOY = "action_deploy"
     DROP = "action_drop"
     VALIDATE = "action_validate"
+    EVENTS = "action_events"
 
     VERSION_LIST = "action_version_list"
     VERSION_CREATE = "action_version_create"
@@ -24,8 +25,9 @@ class EntityBase(Generic[T]):
     Base class for the fully-featured entity classes.
     """
 
-    def __init__(self, entity_model: T):
+    def __init__(self, entity_model: T, workspace_ctx: WorkspaceContext):
         self._entity_model = entity_model
+        self._workspace_ctx = workspace_ctx
 
     @classmethod
     def get_entity_model_type(cls) -> Type[T]:

snowflake/cli/api/entities/utils.py

@@ -1,6 +1,5 @@
 import os
 from pathlib import Path
-from textwrap import dedent
 from typing import Any, List, NoReturn, Optional
 
 import jinja2
@@ -16,7 +15,7 @@ from snowflake.cli._plugins.nativeapp.exceptions import (
 from snowflake.cli._plugins.nativeapp.utils import verify_exists, verify_no_directories
 from snowflake.cli._plugins.stage.diff import (
     DiffResult,
-    StagePath,
+    StagePathType,
     compute_stage_diff,
     preserve_from_diff,
     sync_local_diff_with_stage,
@@ -30,7 +29,11 @@ from snowflake.cli.api.errno import (
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
 )
-from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.exceptions import (
+    DoesNotExistOrUnauthorizedError,
+    NoWarehouseSelectedInSessionError,
+    SnowflakeSQLExecutionError,
+)
 from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.rendering.sql_templates import (
@@ -41,46 +44,21 @@ from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 
 
-def generic_sql_error_handler(
-    err: ProgrammingError, role: Optional[str] = None, warehouse: Optional[str] = None
-) -> NoReturn:
+def generic_sql_error_handler(err: ProgrammingError) -> NoReturn:
     # Potential refactor: If moving away from Python 3.8 and 3.9 to >= 3.10, use match ... case
-    if err.errno == DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED:
-        raise ProgrammingError(
-            msg=dedent(
-                f"""\
-                Received error message '{err.msg}' while executing SQL statement.
-                '{role}' may not have access to warehouse '{warehouse}'.
-                Please grant usage privilege on warehouse to this role.
-                """
-            ),
-            errno=err.errno,
-        )
+    if (
+        err.errno == DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED
+        or "does not exist or not authorized" in err.msg
+    ):
+        raise DoesNotExistOrUnauthorizedError(msg=err.msg) from err
     elif err.errno == NO_WAREHOUSE_SELECTED_IN_SESSION:
-        raise ProgrammingError(
-            msg=dedent(
-                f"""\
-                Received error message '{err.msg}' while executing SQL statement.
-                Please provide a warehouse for the active session role in your project definition file, config.toml file, or via command line.
-                """
-            ),
-            errno=err.errno,
-        )
-    elif "does not exist or not authorized" in err.msg:
-        raise ProgrammingError(
-            msg=dedent(
-                f"""\
-                Received error message '{err.msg}' while executing SQL statement.
-                Please check the name of the resource you are trying to query or the permissions of the role you are using to run the query.
-                """
-            )
-        )
+        raise NoWarehouseSelectedInSessionError(msg=err.msg) from err
     raise err
 
 
 def _get_stage_paths_to_sync(
     local_paths_to_sync: List[Path], deploy_root: Path
-) -> List[StagePath]:
+) -> List[StagePathType]:
     """
     Takes a list of paths (files and directories), returning a list of all files recursively relative to the deploy root.
     """
@@ -254,9 +232,11 @@ def execute_post_deploy_hooks(
 
     with console.phase(f"Executing {deployed_object_type} post-deploy actions"):
         sql_scripts_paths = []
+        display_paths = []
         for hook in post_deploy_hooks:
             if hook.sql_script:
                 sql_scripts_paths.append(hook.sql_script)
+                display_paths.append(hook.display_path)
             else:
                 raise ValueError(
                     f"Unsupported {deployed_object_type} post-deploy hook type: {hook}"
@@ -268,7 +248,7 @@ def execute_post_deploy_hooks(
             sql_scripts_paths,
         )
 
-        for index, sql_script_path in enumerate(sql_scripts_paths):
+        for index, sql_script_path in enumerate(display_paths):
             console.step(f"Executing SQL script: {sql_script_path}")
             _execute_sql_script(
                 script_content=scripts_content_list[index],

snowflake/cli/api/exceptions.py

@@ -188,3 +188,35 @@ class IncompatibleParametersError(UsageError):
         super().__init__(
             f"Parameters {comma_separated_options} and {options_with_quotes[-1]} are incompatible and cannot be used simultaneously."
         )
+
+
+class NoWarehouseSelectedInSessionError(ClickException):
+    def __init__(self, msg: str):
+        super().__init__(
+            "Received the following error message while executing SQL statement:\n"
+            f"'{msg}'\n"
+            "Please provide a warehouse for the active session role in your project definition file, config.toml file, or via command line."
+        )
+
+
+class DoesNotExistOrUnauthorizedError(ClickException):
+    def __init__(self, msg: str):
+        super().__init__(
+            "Received the following error message while executing SQL statement:\n"
+            f"'{msg}'\n"
+            "Please check the name of the resource you are trying to query or the permissions of the role you are using to run the query."
+        )
+
+
+class CouldNotUseObjectError(ClickException):
+    def __init__(self, object_type: ObjectType, name: str):
+        super().__init__(
+            f"Could not use {object_type} {name}. Object does not exist, or operation cannot be performed."
+        )
+
+
+class ShowSpecificObjectMultipleRowsError(RuntimeError):
+    def __init__(self, show_obj_query: str):
+        super().__init__(
+            f"Received multiple rows from result of SQL statement: {show_obj_query}. Usage of 'show_specific_object' may not be properly scoped."
+        )

snowflake/cli/api/identifiers.py

@@ -15,6 +15,7 @@
 from __future__ import annotations
 
 import re
+from pathlib import Path
 
 from click import ClickException
 from snowflake.cli.api.exceptions import FQNInconsistencyError, FQNNameError
@@ -121,8 +122,15 @@ class FQN:
         name = stage
         if stage.startswith("@"):
             name = stage[1:]
+        if stage.startswith("~"):
+            return cls(name="~", database=None, schema=None)
         return cls.from_string(name)
 
+    @classmethod
+    def from_stage_path(cls, stage_path: str) -> "FQN":
+        stage = Path(stage_path).parts[0]
+        return cls.from_stage(stage)
+
     @classmethod
     def from_identifier_model_v1(cls, model: ObjectIdentifierBaseModel) -> "FQN":
         """Create an instance from object model."""

snowflake/cli/api/project/definition_conversion.py

@@ -2,13 +2,19 @@ from __future__ import annotations
 
 import logging
 from pathlib import Path
+from tempfile import TemporaryDirectory, mkstemp
 from typing import Any, Dict, Literal, Optional
 
 from click import ClickException
 from snowflake.cli._plugins.nativeapp.artifacts import (
     BundleMap,
 )
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageEntityModel,
+)
 from snowflake.cli._plugins.snowpark.common import is_name_a_templated_one
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import (
     DEFAULT_ENV_FILE,
     DEFAULT_PAGES_DIR,
@@ -17,7 +23,9 @@ from snowflake.cli.api.constants import (
     SNOWPARK_SHARED_MIXIN,
 )
 from snowflake.cli.api.entities.utils import render_script_template
+from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import (
+    MetaField,
     SqlScriptHookType,
 )
 from snowflake.cli.api.project.schemas.project_definition import (
@@ -37,9 +45,25 @@ from snowflake.cli.api.project.schemas.v1.snowpark.callable import (
 from snowflake.cli.api.project.schemas.v1.snowpark.snowpark import Snowpark
 from snowflake.cli.api.project.schemas.v1.streamlit.streamlit import Streamlit
 from snowflake.cli.api.rendering.jinja import get_basic_jinja_env
+from snowflake.cli.api.utils.definition_rendering import render_definition_template
 
 log = logging.getLogger(__name__)
 
+# A directory to hold temporary files created during in-memory definition conversion
+# We need a global reference to this directory to prevent the object from being
+# garbage collected before the files in the directory are used by other parts
+# of the CLI. The directory will then be deleted on interpreter exit
+_IN_MEMORY_CONVERSION_TEMP_DIR: TemporaryDirectory | None = None
+
+
+def _get_temp_dir() -> TemporaryDirectory:
+    global _IN_MEMORY_CONVERSION_TEMP_DIR
+    if _IN_MEMORY_CONVERSION_TEMP_DIR is None:
+        _IN_MEMORY_CONVERSION_TEMP_DIR = TemporaryDirectory(
+            suffix="_pdf_conversion", ignore_cleanup_errors=True
+        )
+    return _IN_MEMORY_CONVERSION_TEMP_DIR
+
 
 def _is_field_defined(template_context: Optional[Dict[str, Any]], *path: str) -> bool:
     """
@@ -66,20 +90,31 @@ def _is_field_defined(template_context: Optional[Dict[str, Any]], *path: str) ->
 
 def convert_project_definition_to_v2(
     project_root: Path,
-    pd: ProjectDefinition,
+    definition_v1: ProjectDefinition,
     accept_templates: bool = False,
     template_context: Optional[Dict[str, Any]] = None,
+    in_memory: bool = False,
 ) -> ProjectDefinitionV2:
-    _check_if_project_definition_meets_requirements(pd, accept_templates)
+    _check_if_project_definition_meets_requirements(definition_v1, accept_templates)
 
-    snowpark_data = convert_snowpark_to_v2_data(pd.snowpark) if pd.snowpark else {}
-    streamlit_data = convert_streamlit_to_v2_data(pd.streamlit) if pd.streamlit else {}
+    snowpark_data = (
+        convert_snowpark_to_v2_data(definition_v1.snowpark)
+        if definition_v1.snowpark
+        else {}
+    )
+    streamlit_data = (
+        convert_streamlit_to_v2_data(definition_v1.streamlit)
+        if definition_v1.streamlit
+        else {}
+    )
     native_app_data = (
-        convert_native_app_to_v2_data(project_root, pd.native_app, template_context)
-        if pd.native_app
+        convert_native_app_to_v2_data(
+            project_root, definition_v1.native_app, template_context
+        )
+        if definition_v1.native_app
         else {}
     )
-    envs = convert_envs_to_v2(pd)
+    envs = convert_envs_to_v2(definition_v1)
 
     data = {
         "definition_version": "2",
@@ -89,10 +124,22 @@ def convert_project_definition_to_v2(
             native_app_data.get("entities", {}),
         ),
         "mixins": snowpark_data.get("mixins", None),
-        "env": envs,
     }
+    if envs is not None:
+        data["env"] = envs
+
+    if in_memory:
+        # If this is an in-memory conversion, we need to evaluate templates right away
+        # since the file won't be re-read as it would be for a permanent conversion
+        definition_v2 = render_definition_template(data, {}).project_definition
+    else:
+        definition_v2 = ProjectDefinitionV2(**data)
 
-    return ProjectDefinitionV2(**data)
+    # If the user's files have any template tags in them, they
+    # also need to be migrated to point to the v2 entities
+    _convert_templates_in_files(project_root, definition_v1, definition_v2, in_memory)
+
+    return definition_v2
 
 
 def convert_snowpark_to_v2_data(snowpark: Snowpark) -> Dict[str, Any]:
@@ -196,7 +243,7 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
 
 
 def convert_native_app_to_v2_data(
-    project_root,
+    project_root: Path,
     native_app: NativeApp,
     template_context: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
@@ -217,7 +264,7 @@ def convert_native_app_to_v2_data(
         # manifest file from the resultant BundleMap, since the bundle process ensures
         # that only a single source path can map to the corresponding destination path
         bundle_map = BundleMap(
-            project_root=project_root, deploy_root=Path(native_app.deploy_root)
+            project_root=project_root, deploy_root=project_root / native_app.deploy_root
         )
         for artifact in native_app.artifacts:
             bundle_map.add(artifact)
@@ -243,29 +290,6 @@ def convert_native_app_to_v2_data(
         # which use POSIX paths as default values
         return manifest_path.relative_to(project_root).as_posix()
 
-    def _make_template(template: str) -> str:
-        return f"{PROJECT_TEMPLATE_VARIABLE_OPENING} {template} {PROJECT_TEMPLATE_VARIABLE_CLOSING}"
-
-    def _convert_package_script_files(package_scripts: list[str]):
-        # PDFv2 doesn't support package scripts, only post-deploy scripts, so we
-        # need to convert the Jinja syntax from {{ }} to <% %>
-        # Luckily, package scripts only support {{ package_name }}, so let's convert that tag
-        # to v2 template syntax by running it though the template process with a fake
-        # package name that's actually a valid v2 template, which will be evaluated
-        # when the script is used as a post-deploy script
-        fake_package_replacement_template = _make_template(
-            f"ctx.entities.{package_entity_name}.identifier"
-        )
-        jinja_context = dict(package_name=fake_package_replacement_template)
-        post_deploy_hooks = []
-        for script_file in package_scripts:
-            new_contents = render_script_template(
-                project_root, jinja_context, script_file, get_basic_jinja_env()
-            )
-            (project_root / script_file).write_text(new_contents)
-            post_deploy_hooks.append(SqlScriptHookType(sql_script=script_file))
-        return post_deploy_hooks
-
     package_entity_name = "pkg"
     if (
         native_app.package
@@ -303,12 +327,11 @@ def convert_native_app_to_v2_data(
             package["distribution"] = native_app.package.distribution
         package_meta = _make_meta(native_app.package)
         if native_app.package.scripts:
-            converted_post_deploy_hooks = _convert_package_script_files(
-                native_app.package.scripts
-            )
-            package_meta["post_deploy"] = (
-                package_meta.get("post_deploy", []) + converted_post_deploy_hooks
-            )
+            # Package scripts are not supported in PDFv2 but we
+            # don't convert them here, conversion is deferred until
+            # the final v2 Pydantic model is available
+            # (see _convert_templates_in_files())
+            pass
         if package_meta:
             package["meta"] = package_meta
 
@@ -352,6 +375,82 @@ def convert_envs_to_v2(pd: ProjectDefinition):
     return None
 
 
+def _convert_templates_in_files(
+    project_root: Path,
+    definition_v1: ProjectDefinition,
+    definition_v2: ProjectDefinitionV2,
+    in_memory: bool,
+):
+    """Converts templates in other files to the new format"""
+    # TODO handle artifacts using the "templates" processor
+    # For now this only handles Native App package scripts
+    metrics = get_cli_context().metrics
+    metrics.set_counter_default(CLICounterField.PACKAGE_SCRIPTS, 0)
+
+    if (na := definition_v1.native_app) and (pkg := na.package) and pkg.scripts:
+        metrics.set_counter(CLICounterField.PACKAGE_SCRIPTS, 1)
+        cli_console.warning(
+            "WARNING: native_app.package.scripts is deprecated. Please migrate to using native_app.package.post_deploy."
+        )
+        # If the v1 definition has a Native App with a package, we know
+        # that the v2 definition will have exactly one application package entity
+        pkg_entity: ApplicationPackageEntityModel = list(
+            definition_v2.get_entities_by_type(
+                ApplicationPackageEntityModel.get_type()
+            ).values()
+        )[0]
+        converted_post_deploy_hooks = _convert_package_script_files(
+            project_root, pkg.scripts, pkg_entity, in_memory
+        )
+        if pkg_entity.meta is None:
+            pkg_entity.meta = MetaField()
+        if pkg_entity.meta.post_deploy is None:
+            pkg_entity.meta.post_deploy = []
+        pkg_entity.meta.post_deploy += converted_post_deploy_hooks
+
+
+def _convert_package_script_files(
+    project_root: Path,
+    package_scripts: list[str],
+    pkg_model: ApplicationPackageEntityModel,
+    in_memory: bool,
+):
+    # PDFv2 doesn't support package scripts, only post-deploy scripts, so we
+    # need to convert the Jinja syntax from {{ }} to <% %>
+    # Luckily, package scripts only support {{ package_name }}, so let's convert that tag
+    # to v2 template syntax by running it though the template process with a fake
+    # package name that's actually a valid v2 template, which will be evaluated
+    # when the script is used as a post-deploy script
+    # If we're doing an in-memory conversion, we can just hardcode the converted
+    # package name directly into the script since it's being written to a temporary file
+    package_name_replacement = (
+        pkg_model.fqn.name
+        if in_memory
+        else _make_template(f"ctx.entities.{pkg_model.entity_id}.identifier")
+    )
+    jinja_context = dict(package_name=package_name_replacement)
+    post_deploy_hooks = []
+    for script_file in package_scripts:
+        original_script_file = script_file
+        new_contents = render_script_template(
+            project_root, jinja_context, script_file, get_basic_jinja_env()
+        )
+        if in_memory:
+            # If we're converting the definition in-memory, we can't touch
+            # the package scripts on disk, so we'll write them to a temporary file
+            d = _get_temp_dir().name
+            _, script_file = mkstemp(dir=d, suffix="_converted.sql", text=True)
+        (project_root / script_file).write_text(new_contents)
+        hook = SqlScriptHookType(sql_script=script_file)
+        hook._display_path = original_script_file  # noqa: SLF001
+        post_deploy_hooks.append(hook)
+    return post_deploy_hooks
+
+
+def _make_template(template: str) -> str:
+    return f"{PROJECT_TEMPLATE_VARIABLE_OPENING} {template} {PROJECT_TEMPLATE_VARIABLE_CLOSING}"
+
+
 def _check_if_project_definition_meets_requirements(
     pd: ProjectDefinition, accept_templates: bool
 ):

snowflake/cli/api/project/schemas/entities/common.py

@@ -28,6 +28,17 @@ from snowflake.cli.api.project.schemas.updatable_model import (
 class SqlScriptHookType(UpdatableModel):
     sql_script: str = Field(title="SQL file path relative to the project root")
 
+    # Used to store a user-friendly path for this script, when the
+    # value of `sql_script` is a path to a different file
+    # This is used in the UI to display the path relative to the
+    # project root when `sql_script` is a actually path to a temp file
+    # generated by the in-memory PDF v1 to v2 conversion
+    _display_path: str = PrivateAttr(default="")
+
+    @property
+    def display_path(self):
+        return self._display_path or self.sql_script
+
 
 # Currently sql_script is the only supported hook type. Change to a Union once other hook types are added
 PostDeployHook = SqlScriptHookType