snowflake-cli 3.3.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

snowflake/cli/api/entities/utils.py

@@ -1,13 +1,10 @@
 import os
+from enum import Enum
 from pathlib import Path
 from typing import Any, List, NoReturn, Optional
 
 import jinja2
 from click import ClickException
-from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
-    resolve_without_follow,
-)
 from snowflake.cli._plugins.nativeapp.exceptions import (
     InvalidTemplateInFileError,
     MissingScriptError,
@@ -22,10 +19,11 @@ from snowflake.cli._plugins.stage.diff import (
     sync_local_diff_with_stage,
     to_stage_path,
 )
+from snowflake.cli._plugins.stage.manager import DefaultStagePathParts
 from snowflake.cli._plugins.stage.utils import print_diff_to_console
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
 from snowflake.cli.api.cli_global_context import get_cli_context, span
 from snowflake.cli.api.console.abc import AbstractConsole
-from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.errno import (
     DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED,
     NO_WAREHOUSE_SELECTED_IN_SESSION,
@@ -41,6 +39,8 @@ from snowflake.cli.api.rendering.sql_templates import (
     choose_sql_jinja_env_based_on_template_syntax,
 )
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
+from snowflake.cli.api.sql_execution import SqlExecutor
+from snowflake.cli.api.utils.path_utils import resolve_without_follow
 from snowflake.connector import ProgrammingError
 
 
@@ -80,12 +80,11 @@ def sync_deploy_root_with_stage(
     console: AbstractConsole,
     deploy_root: Path,
     package_name: str,
-    stage_schema: str,
     bundle_map: BundleMap,
     role: str,
     prune: bool,
     recursive: bool,
-    stage_fqn: str,
+    stage_path: DefaultStagePathParts,
     local_paths_to_sync: List[Path] | None = None,
     print_diff: bool = True,
 ) -> DiffResult:
@@ -98,32 +97,37 @@ def sync_deploy_root_with_stage(
         role (str): The name of the role to use for queries and commands.
         prune (bool): Whether to prune artifacts from the stage that don't exist locally.
         recursive (bool): Whether to traverse directories recursively.
-        stage_fqn (str): The name of the stage to diff against and upload to.
+        stage_path (DefaultStagePathParts): stage path object.
+
         local_paths_to_sync (List[Path], optional): List of local paths to sync. Defaults to None to sync all
-         local paths. Note that providing an empty list here is equivalent to None.
+        local paths. Note that providing an empty list here is equivalent to None.
         print_diff (bool): Whether to print the diff between the local files and the remote stage. Defaults to True
 
     Returns:
         A `DiffResult` instance describing the changes that were performed.
     """
-
     sql_facade = get_snowflake_facade()
+    schema = stage_path.schema
+    stage_fqn = stage_path.stage
     # Does a stage already exist within the application package, or we need to create one?
     # Using "if not exists" should take care of either case.
     console.step(
         f"Checking if stage {stage_fqn} exists, or creating a new one if none exists."
     )
     if not sql_facade.stage_exists(stage_fqn):
-        sql_facade.create_schema(stage_schema, database=package_name)
+        sql_facade.create_schema(schema, database=package_name)
         sql_facade.create_stage(stage_fqn)
 
     # Perform a diff operation and display results to the user for informational purposes
     if print_diff:
         console.step(
-            "Performing a diff between the Snowflake stage and your local deploy_root ('%s') directory."
-            % deploy_root.resolve()
+            f"Performing a diff between the Snowflake stage: {stage_path.path} and your local deploy_root: {deploy_root.resolve()}."
         )
-    diff: DiffResult = compute_stage_diff(deploy_root, stage_fqn)
+
+    diff: DiffResult = compute_stage_diff(
+        local_root=deploy_root,
+        stage_path=stage_path,
+    )
 
     if local_paths_to_sync:
         # Deploying specific files/directories
@@ -184,7 +188,7 @@ def sync_deploy_root_with_stage(
             role=role,
             deploy_root_path=deploy_root,
             diff_result=diff,
-            stage_fqn=stage_fqn,
+            stage_full_path=stage_path.full_path,
         )
     return diff
 
@@ -336,3 +340,40 @@ def print_messages(console: AbstractConsole, cursor_results: list[tuple[str]]):
     for message in messages:
         console.warning(message)
     console.message("")
+
+
+def get_sql_executor() -> SqlExecutor:
+    """Returns an SQL Executor that uses the connection from the current CLI context"""
+    return SqlExecutor()
+
+
+class EntityActions(str, Enum):
+    BUNDLE = "action_bundle"
+    DEPLOY = "action_deploy"
+    DROP = "action_drop"
+    VALIDATE = "action_validate"
+    EVENTS = "action_events"
+    DIFF = "action_diff"
+
+    VERSION_LIST = "action_version_list"
+    VERSION_CREATE = "action_version_create"
+    VERSION_DROP = "action_version_drop"
+
+    RELEASE_DIRECTIVE_UNSET = "action_release_directive_unset"
+    RELEASE_DIRECTIVE_SET = "action_release_directive_set"
+    RELEASE_DIRECTIVE_LIST = "action_release_directive_list"
+    RELEASE_DIRECTIVE_ADD_ACCOUNTS = "action_release_directive_add_accounts"
+    RELEASE_DIRECTIVE_REMOVE_ACCOUNTS = "action_release_directive_remove_accounts"
+
+    RELEASE_CHANNEL_LIST = "action_release_channel_list"
+    RELEASE_CHANNEL_ADD_ACCOUNTS = "action_release_channel_add_accounts"
+    RELEASE_CHANNEL_REMOVE_ACCOUNTS = "action_release_channel_remove_accounts"
+    RELEASE_CHANNEL_ADD_VERSION = "action_release_channel_add_version"
+    RELEASE_CHANNEL_REMOVE_VERSION = "action_release_channel_remove_version"
+    RELEASE_CHANNEL_SET_ACCOUNTS = "action_release_channel_set_accounts"
+
+    PUBLISH = "action_publish"
+
+    @property
+    def get_action_name(self):
+        return self.value.replace("action_", "")

snowflake/cli/api/errno.py

@@ -54,6 +54,7 @@ APPLICATION_PACKAGE_MANIFEST_CONTAINER_IMAGE_URL_BAD_VALUE = 93148
 CANNOT_GRANT_NON_MANIFEST_PRIVILEGE = 93118
 APPLICATION_OWNS_EXTERNAL_OBJECTS = 93128
 APPLICATION_PACKAGE_PATCH_ALREADY_EXISTS = 93168
+CANNOT_ADD_PATCH_WITH_NON_INCREASING_PATCH_NUMBER = 93167
 APPLICATION_PACKAGE_CANNOT_SET_EXTERNAL_DISTRIBUTION_WITH_SPCS = 93197
 NATIVE_APPLICATION_MANIFEST_UNRECOGNIZED_FIELD = 93301
 NATIVE_APPLICATION_MANIFEST_UNEXPECTED_VALUE_FOR_PROPERTY = 93302
@@ -64,8 +65,10 @@ CANNOT_DISABLE_MANDATORY_TELEMETRY = 93329
 VERSION_NOT_ADDED_TO_RELEASE_CHANNEL = 512008
 CANNOT_DISABLE_RELEASE_CHANNELS = 512001
 RELEASE_DIRECTIVES_VERSION_PATCH_NOT_FOUND = 93036
+RELEASE_DIRECTIVE_UNAPPROVED_VERSION_OR_PATCH = 93074
 RELEASE_DIRECTIVE_DOES_NOT_EXIST = 93090
 VERSION_DOES_NOT_EXIST = 93031
+CANNOT_CREATE_VERSION_WITH_NON_ZERO_PATCH = 93170
 VERSION_NOT_IN_RELEASE_CHANNEL = 512010
 ACCOUNT_DOES_NOT_EXIST = 1999
 ACCOUNT_HAS_TOO_MANY_QUALIFIERS = 906

snowflake/cli/api/exceptions.py

@@ -15,7 +15,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional
+from typing import List, Optional
 
 from click.exceptions import ClickException, UsageError
 from snowflake.cli.api.constants import ObjectType
@@ -54,6 +54,13 @@ class InvalidPluginConfiguration(ClickException):
         return f"Invalid plugin configuration. {self.message}"
 
 
+class PluginNotInstalledError(ClickException):
+    def __init__(self, plugin_name, installed_plugins: List[str]):
+        super().__init__(
+            f"Plugin {plugin_name} is not installed. Available plugins: {', '.join(installed_plugins)}."
+        )
+
+
 class SnowflakeConnectionError(ClickException):
     def __init__(self, snowflake_err: Exception):
         super().__init__(f"Could not connect to Snowflake. Reason: {snowflake_err}")

snowflake/cli/api/feature_flags.py

@@ -66,5 +66,5 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID = BooleanFlag(
         "ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID", False
     )
+    ENABLE_SNOWPARK_GLOB_SUPPORT = BooleanFlag("ENABLE_SNOWPARK_GLOB_SUPPORT", False)
     ENABLE_SPCS_SERVICE_EVENTS = BooleanFlag("ENABLE_SPCS_SERVICE_EVENTS", False)
-    ENABLE_SPCS_SERVICE_METRICS = BooleanFlag("ENABLE_SPCS_SERVICE_METRICS", False)

snowflake/cli/api/plugins/plugin_config.py

@@ -17,6 +17,16 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Any, Dict, List
 
+from snowflake.cli.api.config import (
+    PLUGIN_ENABLED_KEY,
+    PLUGINS_SECTION_PATH,
+    config_section_exists,
+    get_config_section,
+    get_config_value,
+    get_plugins_config,
+)
+from snowflake.cli.api.exceptions import InvalidPluginConfiguration
+
 
 @dataclass
 class PluginConfig:
@@ -25,8 +35,37 @@ class PluginConfig:
 
 
 class PluginConfigProvider:
-    def get_enabled_plugin_names(self) -> List[str]:
-        raise NotImplementedError()
+    @staticmethod
+    def get_enabled_plugin_names() -> List[str]:
+        enabled_plugins = []
+        for plugin_name, plugin_config_section in get_plugins_config().items():
+            enabled = plugin_config_section.get(PLUGIN_ENABLED_KEY, False)
+            _assert_value_is_bool(
+                enabled, value_name=PLUGIN_ENABLED_KEY, plugin_name=plugin_name
+            )
+            if enabled:
+                enabled_plugins.append(plugin_name)
+        return enabled_plugins
+
+    @staticmethod
+    def get_config(plugin_name: str) -> PluginConfig:
+        config_path = PLUGINS_SECTION_PATH + [plugin_name]
+        plugin_config = PluginConfig(is_plugin_enabled=False, internal_config={})
+        plugin_config.is_plugin_enabled = get_config_value(
+            *config_path, key=PLUGIN_ENABLED_KEY, default=False
+        )
+        _assert_value_is_bool(
+            plugin_config.is_plugin_enabled,
+            value_name=PLUGIN_ENABLED_KEY,
+            plugin_name=plugin_name,
+        )
+        if config_section_exists(*config_path, "config"):
+            plugin_config.internal_config = get_config_section(*config_path, "config")
+        return plugin_config
+
 
-    def get_config(self, plugin_name: str) -> PluginConfig:
-        raise NotImplementedError()
+def _assert_value_is_bool(value, *, value_name: str, plugin_name: str) -> None:
+    if type(value) is not bool:
+        raise InvalidPluginConfiguration(
+            f'[{plugin_name}]: "{value_name}" must be a boolean'
+        )

snowflake/cli/api/project/definition_conversion.py

@@ -222,10 +222,11 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
         environment_file,
         pages_dir,
     ]
-    artifacts = [a for a in artifacts if a is not None]
+    artifacts = [str(a) for a in artifacts if a is not None]
 
     if streamlit.additional_source_files:
-        artifacts.extend(streamlit.additional_source_files)
+        for additional_file in streamlit.additional_source_files:
+            artifacts.append(str(additional_file))
 
     identifier = {"name": streamlit.name}
     if streamlit.schema_name:

snowflake/cli/api/project/definition_helper.py

@@ -0,0 +1,31 @@
+from typing import Optional
+
+from click import UsageError
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.constants import ObjectType
+from snowflake.cli.api.exceptions import NoProjectDefinitionError
+
+
+def get_entity_from_project_definition(
+    entity_type: ObjectType, entity_id: Optional[str] = None
+):
+    cli_context = get_cli_context()
+    pd = cli_context.project_definition
+    entities = pd.get_entities_by_type(entity_type=entity_type.value.cli_name)
+
+    if not entities:
+        raise NoProjectDefinitionError(
+            project_type=entity_type.value.sf_name,
+            project_root=cli_context.project_root,
+        )
+
+    if entity_id and entity_id not in entities:
+        raise UsageError(f"No '{entity_id}' entity in project definition file.")
+    elif len(entities.keys()) == 1:
+        entity_id = list(entities.keys())[0]
+
+    if entity_id is None:
+        raise UsageError(
+            f"Multiple {entity_type.value.sf_plural_name} found. Please provide entity id for the operation."
+        )
+    return entities[entity_id]

snowflake/cli/api/project/project_paths.py

@@ -0,0 +1,28 @@
+from dataclasses import dataclass
+from pathlib import Path
+
+from snowflake.cli.api.secure_path import SecurePath
+
+
+@dataclass
+class ProjectPaths:
+    """
+    This class allows you to manage files paths related to given project.
+    Class provides bundle root path and allows to remove it.
+    """
+
+    project_root: Path
+
+    @property
+    def bundle_root(self) -> Path:
+        return bundle_root(self.project_root)
+
+    def remove_up_bundle_root(self) -> None:
+        if self.bundle_root.exists():
+            SecurePath(self.bundle_root).rmdir(recursive=True)
+
+
+def bundle_root(root: Path, app_type: str | None = None) -> Path:
+    if app_type:
+        return root / "output" / "bundle" / app_type
+    return root / "output" / "bundle"

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

@@ -15,9 +15,10 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Dict, Generic, List, Optional, TypeVar, Union
+from typing import Any, Dict, Generic, List, Optional, TypeVar, Union
 
 from pydantic import Field, PrivateAttr, field_validator
+from pydantic_core.core_schema import ValidationInfo
 from snowflake.cli.api.identifiers import FQN
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
@@ -61,6 +62,15 @@ class MetaField(UpdatableModel):
         default=None,
     )
 
+    depends_on: Optional[List[str]] = Field(
+        title="Entities that need to be deployed before this one", default_factory=list
+    )
+
+    action_arguments: Optional[Dict[str, Dict[str, Union[int, bool, str]]]] = Field(
+        title="Arguments that will be used, when this entity is called as a dependency of other entity",
+        default_factory=dict,
+    )
+
     @field_validator("use_mixins", mode="before")
     @classmethod
     def ensure_use_mixins_is_a_list(
@@ -70,6 +80,35 @@ class MetaField(UpdatableModel):
             return [mixins]
         return mixins
 
+    @field_validator("action_arguments", mode="before")
+    @classmethod
+    def arguments_validator(cls, arguments: Dict, info: ValidationInfo) -> Dict:
+        duplicated_run = (
+            info.context.get("is_duplicated_run", False) if info.context else False
+        )
+        if not duplicated_run:
+            for argument_dict in arguments.values():
+                for k, v in argument_dict.items():
+                    argument_dict[k] = cls._cast_value(v)
+
+        return arguments
+
+    @staticmethod
+    def _cast_value(value: str) -> Union[int, bool, str]:
+        if value.lower() in ["true", "false"]:
+            return value.lower() == "true"
+
+        try:
+            return int(value)
+        except ValueError:
+            return value
+
+    def __eq__(self, other):
+        return self.entity_id == other.entity_id
+
+    def __hash__(self):
+        return hash(self.entity_id)
+
 
 class Identifier(UpdatableModel):
     name: str = Field(title="Entity name")
@@ -141,6 +180,23 @@ class ImportsBaseModel:
         return f"IMPORTS = ({imports})"
 
 
+class Grant(UpdatableModel):
+    privilege: str = Field(title="Required privileges")
+    role: str = Field(title="Role to which the privileges will be granted")
+
+    def get_grant_sql(self, entity_model: EntityModelBase) -> str:
+        return f"GRANT {self.privilege} ON {entity_model.get_type().upper()} {entity_model.fqn.sql_identifier} TO ROLE {self.role}"
+
+
+class GrantBaseModel(UpdatableModel):
+    grants: Optional[List[Grant]] = Field(title="List of grants", default=None)
+
+    def get_grant_sqls(self) -> list[str]:
+        return (
+            [grant.get_grant_sql(self) for grant in self.grants] if self.grants else []
+        )
+
+
 class ExternalAccessBaseModel:
     external_access_integrations: Optional[List[str]] = Field(
         title="Names of external access integrations needed for this entity to access external networks",
@@ -162,3 +218,76 @@ class ExternalAccessBaseModel:
             return None
         secrets = ", ".join(f"'{key}'={value}" for key, value in self.secrets.items())
         return f"secrets=({secrets})"
+
+
+class ProcessorMapping(UpdatableModel):
+    name: str = Field(
+        title="Name of a processor to invoke on a collection of artifacts."
+    )
+    properties: Optional[Dict[str, Any]] = Field(
+        title="A set of key-value pairs used to configure the output of the processor. Consult a specific processor's documentation for more details on the supported properties.",
+        default=None,
+    )
+
+
+class PathMapping(UpdatableModel):
+    src: str = Field(
+        title="Source path or glob pattern (relative to project root)", default=None
+    )
+
+    dest: Optional[str] = Field(
+        title="Destination path on stage",
+        description="Paths are relative to stage root; paths ending with a slash indicate that the destination is a directory which source files should be copied into.",
+        default=None,
+    )
+
+    processors: Optional[List[Union[str, ProcessorMapping]]] = Field(
+        title="List of processors to apply to matching source files during bundling.",
+        default=[],
+    )
+
+    @field_validator("processors")
+    @classmethod
+    def transform_processors(
+        cls, input_values: Optional[List[Union[str, Dict, ProcessorMapping]]]
+    ) -> List[ProcessorMapping]:
+        if input_values is None:
+            return []
+
+        transformed_processors: List[ProcessorMapping] = []
+        for input_processor in input_values:
+            if isinstance(input_processor, str):
+                transformed_processors.append(ProcessorMapping(name=input_processor))
+            elif isinstance(input_processor, Dict):
+                transformed_processors.append(ProcessorMapping(**input_processor))
+            else:
+                transformed_processors.append(input_processor)
+        return transformed_processors
+
+
+Artifacts = List[Union[PathMapping, str]]
+
+
+class EntityModelBaseWithArtifacts(EntityModelBase):
+    artifacts: Artifacts = Field(
+        title="List of paths or file source/destination pairs to add to the deploy root",
+    )
+    deploy_root: Optional[str] = Field(
+        title="Folder at the root of your project where the build step copies the artifacts",
+        default="output/deploy/",
+    )
+
+    @field_validator("artifacts")
+    @classmethod
+    def transform_artifacts(cls, orig_artifacts: Artifacts) -> List[PathMapping]:
+        transformed_artifacts: List[PathMapping] = []
+        if orig_artifacts is None:
+            return transformed_artifacts
+
+        for artifact in orig_artifacts:
+            if isinstance(artifact, PathMapping):
+                transformed_artifacts.append(artifact)
+            else:
+                transformed_artifacts.append(PathMapping(src=artifact))
+
+        return transformed_artifacts

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

@@ -24,6 +24,12 @@ from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
     ApplicationPackageEntityModel,
 )
+from snowflake.cli._plugins.notebook.notebook_entity import NotebookEntity
+from snowflake.cli._plugins.notebook.notebook_entity_model import NotebookEntityModel
+from snowflake.cli._plugins.project.project_entity_model import (
+    ProjectEntity,
+    ProjectEntityModel,
+)
 from snowflake.cli._plugins.snowpark.snowpark_entity import (
     FunctionEntity,
     ProcedureEntity,
@@ -32,6 +38,20 @@ from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
     FunctionEntityModel,
     ProcedureEntityModel,
 )
+from snowflake.cli._plugins.spcs.compute_pool.compute_pool_entity import (
+    ComputePoolEntity,
+)
+from snowflake.cli._plugins.spcs.compute_pool.compute_pool_entity_model import (
+    ComputePoolEntityModel,
+)
+from snowflake.cli._plugins.spcs.image_repository.image_repository_entity import (
+    ImageRepositoryEntity,
+)
+from snowflake.cli._plugins.spcs.image_repository.image_repository_entity_model import (
+    ImageRepositoryEntityModel,
+)
+from snowflake.cli._plugins.spcs.services.service_entity import ServiceEntity
+from snowflake.cli._plugins.spcs.services.service_entity_model import ServiceEntityModel
 from snowflake.cli._plugins.streamlit.streamlit_entity import StreamlitEntity
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
@@ -42,7 +62,12 @@ Entity = Union[
     ApplicationPackageEntity,
     StreamlitEntity,
     ProcedureEntity,
+    ProjectEntity,
     FunctionEntity,
+    ComputePoolEntity,
+    ImageRepositoryEntity,
+    ServiceEntity,
+    NotebookEntity,
 ]
 EntityModel = Union[
     ApplicationEntityModel,
@@ -50,6 +75,11 @@ EntityModel = Union[
     StreamlitEntityModel,
     FunctionEntityModel,
     ProcedureEntityModel,
+    ComputePoolEntityModel,
+    ImageRepositoryEntityModel,
+    ServiceEntityModel,
+    NotebookEntityModel,
+    ProjectEntityModel,
 ]
 
 ALL_ENTITIES: List[Entity] = [*get_args(Entity)]

snowflake/cli/api/project/schemas/project_definition.py

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass
 from types import UnionType
 from typing import Any, Dict, List, Optional, Union, get_args, get_origin
@@ -262,6 +263,21 @@ class DefinitionV20(_ProjectDefinitionBase):
         data = cls._merge_data(data, entity)
         return data
 
+    @model_validator(mode="after")
+    def validate_dependencies(self):
+        """
+        Checks if entities listed in depends_on section exist in the project
+        """
+        missing_dependencies = defaultdict(list)
+        for entity_id, entity in self.entities.items():
+            if entity.meta:
+                for dependency in entity.meta.depends_on:
+                    if dependency not in self.entities:
+                        missing_dependencies[entity_id].append(dependency)
+
+        if missing_dependencies:
+            raise ValueError(_get_missing_dependencies_message(missing_dependencies))
+
     @classmethod
     def _merge_data(
         cls,
@@ -354,3 +370,14 @@ def _unique_extend(list_a: List, list_b: List) -> List:
         if all(item != x for x in list_a):
             new_list.append(item)
     return new_list
+
+
+def _get_missing_dependencies_message(
+    missing_dependencies: Dict[str, List[str]]
+) -> str:
+    missing_dependencies_message = []
+    for entity_id, dependencies in missing_dependencies.items():
+        missing_dependencies_message.append(
+            f"\n Entity {entity_id} depends on non-existing entities: {', '.join(dependencies)}"
+        )
+    return "".join(missing_dependencies_message)

snowflake/cli/api/project/schemas/updatable_model.py

@@ -122,10 +122,10 @@ class UpdatableModel(BaseModel):
             class_dict = class_.__dict__
             field_annotations.update(class_dict.get("__annotations__", {}))
 
-            if "model_fields" in class_dict:
+            if "model_fields" in class_dict and class_.model_fields:
                 # This means the class dict has already been processed by Pydantic
                 # All fields should properly be populated in model_fields
-                field_values.update(class_dict["model_fields"])
+                field_values.update(class_.model_fields)
             else:
                 # If Pydantic did not process this class yet, get the values from class_dict directly
                 field_values.update(class_dict)

snowflake/cli/api/project/schemas/v1/native_app/native_app.py

@@ -15,16 +15,16 @@
 from __future__ import annotations
 
 import re
-from typing import List, Optional, Union
+from typing import List, Optional
 
 from pydantic import Field, field_validator
+from snowflake.cli.api.project.schemas.entities.common import Artifacts, PathMapping
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 from snowflake.cli.api.project.schemas.v1.native_app.application import (
     Application,
     ApplicationV11,
 )
 from snowflake.cli.api.project.schemas.v1.native_app.package import Package, PackageV11
-from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import (
     SCHEMA_AND_NAME,
 )
@@ -34,7 +34,7 @@ class NativeApp(UpdatableModel):
     name: str = Field(
         title="Project identifier",
     )
-    artifacts: List[Union[PathMapping, str]] = Field(
+    artifacts: Artifacts = Field(
         title="List of file source and destination pairs to add to the deploy root",
     )
     bundle_root: Optional[str] = Field(
@@ -69,10 +69,8 @@ class NativeApp(UpdatableModel):
 
     @field_validator("artifacts")
     @classmethod
-    def transform_artifacts(
-        cls, orig_artifacts: List[Union[PathMapping, str]]
-    ) -> List[PathMapping]:
-        transformed_artifacts = []
+    def transform_artifacts(cls, orig_artifacts: Artifacts) -> List[PathMapping]:
+        transformed_artifacts: List[PathMapping] = []
         if orig_artifacts is None:
             return transformed_artifacts
 

snowflake/cli/api/secure_path.py

@@ -104,6 +104,12 @@ class SecurePath:
         """
         return self._path.is_file()
 
+    def glob(self, pattern: str):
+        """
+        Return a generator yielding Path objects that match the given pattern.
+        """
+        return self._path.glob(pattern)
+
     @property
     def name(self) -> str:
         """A string representing the final path component."""

snowflake/cli/api/sql_execution.py

@@ -92,7 +92,11 @@ class BaseSqlExecutor:
 
     def execute_queries(self, queries: str, **kwargs):
         """Executes multiple SQL queries (passed as one string) and returns the results as a list"""
-        return list(self._execute_string(dedent(queries), **kwargs))
+
+        # Without remove_comments=True, connectors might throw an error if there is a comment at the end of the file
+        return list(
+            self._execute_string(dedent(queries), remove_comments=True, **kwargs)
+        )
 
 
 class SqlExecutor(BaseSqlExecutor):