snowflake-cli 3.2.2__py3-none-any.whl → 3.4.1__py3-none-any.whl

snowflake/cli/api/errno.py

@@ -14,17 +14,77 @@
 
 # General errors
 NO_WAREHOUSE_SELECTED_IN_SESSION = 606
+EMPTY_SQL_STATEMENT = 900
 
-DOES_NOT_EXIST_OR_NOT_AUTHORIZED = 2003
-DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED = 2043
-INSUFFICIENT_PRIVILEGES = 3001
+SQL_COMPILATION_ERROR = 1003
+OBJECT_ALREADY_EXISTS_IN_DOMAIN = 1998
+OBJECT_ALREADY_EXISTS = 2002
+DOES_NOT_EXIST_OR_NOT_AUTHORIZED = 2003  # BASE_TABLE_OR_VIEW_NOT_FOUND
+DUPLICATE_COLUMN_NAME = 2025
+VIEW_EXPANSION_FAILED = 2037
+DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED = (
+    2043  # OBJECT_DOES_NOT_EXIST_OR_CANNOT_PERFORM_OPERATION
+)
+INSUFFICIENT_PRIVILEGES = 3001  # NOT_AUTHORIZED
+INVALID_OBJECT_TYPE_FOR_SPECIFIED_PRIVILEGE = 3008
+ROLE_NOT_ASSIGNED = 3013
+NO_INDIVIDUAL_PRIVS = 3028
+OBJECT_ALREADY_EXISTS_NO_PRIVILEGES = 3041
 
 # Native Apps
+APPLICATION_PACKAGE_MANIFEST_SPECIFIED_FILE_NOT_FOUND = 93003
+APPLICATION_FILE_NOT_FOUND_ON_STAGE = 93009
+CANNOT_GRANT_OBJECT_NOT_IN_APP_PACKAGE = 93011
+CANNOT_GRANT_RESTRICTED_PRIVILEGE_TO_APP_PACKAGE_SHARE = 93012
+APPLICATION_PACKAGE_VERSION_ALREADY_EXISTS = 93030
+APPLICATION_PACKAGE_VERSION_NAME_TOO_LONG = 93035
+APPLICATION_PACKAGE_PATCH_DOES_NOT_EXIST = 93036
+APPLICATION_PACKAGE_MAX_VERSIONS_HIT = 93037
 CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION = 93044
 CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES = 93045
 ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93046
+NO_VERSIONS_AVAILABLE_FOR_ACCOUNT = 93054
 NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93055
 APPLICATION_NO_LONGER_AVAILABLE = 93079
+APPLICATION_INSTANCE_FAILED_TO_RUN_SETUP_SCRIPT = 93082
+APPLICATION_INSTANCE_NO_ACTIVE_WAREHOUSE_FOR_CREATE_OR_UPGRADE = 93083
+APPLICATION_INSTANCE_EMPTY_SETUP_SCRIPT = 93084
+VERSION_REFERENCED_BY_RELEASE_DIRECTIVE = 93088
+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
+NATIVE_APPLICATION_MANIFEST_GENERIC_JSON_ERROR = 93303
+NATIVE_APPLICATION_MANIFEST_INVALID_SYNTAX = 93300
 APPLICATION_REQUIRES_TELEMETRY_SHARING = 93321
 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
+CANNOT_MODIFY_RELEASE_CHANNEL_ACCOUNTS = 512017
+VERSION_ALREADY_ADDED_TO_RELEASE_CHANNEL = 512005
+MAX_VERSIONS_IN_RELEASE_CHANNEL_REACHED = 512004
+MAX_UNBOUND_VERSIONS_REACHED = 512023
+CANNOT_DEREGISTER_VERSION_ASSOCIATED_WITH_CHANNEL = 512021
+TARGET_ACCOUNT_USED_BY_OTHER_RELEASE_DIRECTIVE = 93091
+
+
+ERR_JAVASCRIPT_EXECUTION = 100132
+
+SNOWSERVICES_IMAGE_REPOSITORY_IMAGE_IMPORT_TO_NATIVE_APP_FAIL = 397007
+SNOWSERVICES_IMAGE_MANIFEST_NOT_FOUND = 397012
+SNOWSERVICES_IMAGE_REPOSITORY_FAILS_TO_RETRIEVE_IMAGE_HASH_NEW = 397013
+
+NO_REFERENCE_SET_FOR_DEFINITION = 505019
+NO_ACTIVE_REF_DEFINITION_WITH_REF_NAME_IN_APPLICATION = 505026

snowflake/cli/api/feature_flags.py

@@ -24,20 +24,31 @@ from snowflake.cli.api.config import (
 
 class BooleanFlag(NamedTuple):
     name: str
-    default: bool = False
+    default: bool | None = False
 
 
 @unique
 class FeatureFlagMixin(Enum):
-    def is_enabled(self) -> bool:
+    def get_value(self) -> bool | None:
         return get_config_bool_value(
             *FEATURE_FLAGS_SECTION_PATH,
             key=self.value.name.lower(),
             default=self.value.default,
         )
 
-    def is_disabled(self):
-        return not self.is_enabled()
+    def is_enabled(self) -> bool:
+        return self.get_value() is True
+
+    def is_disabled(self) -> bool:
+        return self.get_value() is False
+
+    def is_set(self) -> bool:
+        return (
+            get_config_bool_value(
+                *FEATURE_FLAGS_SECTION_PATH, key=self.value.name.lower(), default=None
+            )
+            is not None
+        )
 
     def env_variable(self):
         return get_env_variable_name(*FEATURE_FLAGS_SECTION_PATH, key=self.value.name)
@@ -52,3 +63,7 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_STREAMLIT_VERSIONED_STAGE = BooleanFlag(
         "ENABLE_STREAMLIT_VERSIONED_STAGE", False
     )
+    ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID = BooleanFlag(
+        "ENABLE_SEPARATE_AUTHENTICATION_POLICY_ID", False
+    )
+    ENABLE_SNOWPARK_GLOB_SUPPORT = BooleanFlag("ENABLE_SNOWPARK_GLOB_SUPPORT", False)

snowflake/cli/api/metrics.py

@@ -116,10 +116,8 @@ class CLIMetricsSpan:
     children: Set[CLIMetricsSpan] = field(init=False, default_factory=set)
 
     # private state
-    # start time of the step from the monotonic clock in order to calculate execution time
-    _monotonic_start: float = field(
-        init=False, default_factory=lambda: time.monotonic()
-    )
+    # start time of the step from a performance counter in order to calculate execution time
+    _start_time: float = field(init=False, default_factory=time.perf_counter)
 
     def __hash__(self) -> int:
         return hash(self.span_id)
@@ -154,7 +152,7 @@ class CLIMetricsSpan:
         if error:
             self.error = error
 
-        self.execution_time = time.monotonic() - self._monotonic_start
+        self.execution_time = time.perf_counter() - self._start_time
 
     def to_dict(self) -> Dict:
         """
@@ -191,9 +189,10 @@ class CLIMetrics:
     _in_progress_spans: List[CLIMetricsSpan] = field(init=False, default_factory=list)
     # list of finished steps for telemetry to process
     _completed_spans: List[CLIMetricsSpan] = field(init=False, default_factory=list)
-    # monotonic clock time of when this class was initialized to approximate when the command first started executing
-    _monotonic_start: float = field(
-        init=False, default_factory=lambda: time.monotonic(), compare=False
+    # clock time of a performance counter when this class was initialized
+    # to approximate when the command first started executing
+    _start_time: float = field(
+        init=False, default_factory=time.perf_counter, compare=False
     )
 
     def clone(self) -> CLIMetrics:
@@ -223,7 +222,7 @@ class CLIMetrics:
         return self._in_progress_spans[-1] if len(self._in_progress_spans) > 0 else None
 
     @contextmanager
-    def start_span(self, name: str) -> Iterator[CLIMetricsSpan]:
+    def span(self, name: str) -> Iterator[CLIMetricsSpan]:
         """
         Starts a new span that tracks various metrics throughout its execution
 
@@ -236,7 +235,7 @@ class CLIMetrics:
         """
         new_span = CLIMetricsSpan(
             name=name,
-            start_time=time.monotonic() - self._monotonic_start,
+            start_time=time.perf_counter() - self._start_time,
             parent=self.current_span,
         )
 
@@ -275,34 +274,29 @@ class CLIMetrics:
     @property
     def completed_spans(self) -> List[Dict]:
         """
-        Returns the completed spans tracked throughout a command, sorted by start time, for reporting telemetry
+        Returns the completed spans tracked throughout a command for reporting telemetry
 
         Ensures that the spans we send are within the configured limits and marks
         certain spans as trimmed if their children would bypass the limits we set
         """
         # take spans breadth-first within the depth and total limits
         # since we care more about the big picture than granularity
-        spans_to_report = set(
-            nsmallest(
-                n=self.SPAN_TOTAL_LIMIT,
-                iterable=(
-                    span
-                    for span in self._completed_spans
-                    if span.span_depth <= self.SPAN_DEPTH_LIMIT
-                ),
-                key=lambda span: (span.span_depth, span.start_time),
-            )
+        spans_to_report = nsmallest(
+            n=self.SPAN_TOTAL_LIMIT,
+            iterable=(
+                span
+                for span in self._completed_spans
+                if span.span_depth <= self.SPAN_DEPTH_LIMIT
+            ),
+            key=lambda span: (span.span_depth, span.start_time, span.execution_time),
         )
 
-        # sort by start time to make reading the payload easier
-        sorted_spans_to_report = sorted(
-            spans_to_report, key=lambda span: span.start_time
-        )
+        spans_to_report_set = set(spans_to_report)
 
         return [
             {
                 **span.to_dict(),
-                CLIMetricsSpan.TRIMMED_KEY: not span.children <= spans_to_report,
+                CLIMetricsSpan.TRIMMED_KEY: not span.children <= spans_to_report_set,
             }
-            for span in sorted_spans_to_report
+            for span in spans_to_report
         ]

snowflake/cli/api/project/definition_conversion.py

@@ -13,7 +13,6 @@ from snowflake.cli._plugins.nativeapp.artifacts import (
     bundle_artifacts,
 )
 from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
-from snowflake.cli._plugins.nativeapp.codegen.compiler import TEMPLATES_PROCESSOR
 from snowflake.cli._plugins.nativeapp.codegen.templates.templates_processor import (
     TemplatesProcessor,
 )
@@ -223,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:
@@ -457,7 +457,7 @@ def _convert_templates_in_files(
             artifact
             for artifact in pkg_model.artifacts
             for processor in artifact.processors
-            if processor.name == TEMPLATES_PROCESSOR
+            if processor.name.lower() == TemplatesProcessor.NAME
         ]
         if not in_memory and artifacts_to_template:
             metrics.set_counter(CLICounterField.TEMPLATES_PROCESSOR, 1)

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,8 @@ 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.snowpark.snowpark_entity import (
     FunctionEntity,
     ProcedureEntity,
@@ -43,6 +45,7 @@ Entity = Union[
     StreamlitEntity,
     ProcedureEntity,
     FunctionEntity,
+    NotebookEntity,
 ]
 EntityModel = Union[
     ApplicationEntityModel,
@@ -50,6 +53,7 @@ EntityModel = Union[
     StreamlitEntityModel,
     FunctionEntityModel,
     ProcedureEntityModel,
+    NotebookEntityModel,
 ]
 
 ALL_ENTITIES: List[Entity] = [*get_args(Entity)]

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

@@ -14,13 +14,19 @@
 
 from __future__ import annotations
 
+from collections import defaultdict
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Union
+from types import UnionType
+from typing import Any, Dict, List, Optional, Union, get_args, get_origin
 
 from packaging.version import Version
 from pydantic import Field, ValidationError, field_validator, model_validator
 from pydantic_core.core_schema import ValidationInfo
 from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageChildrenTypes,
+    ApplicationPackageEntityModel,
+)
 from snowflake.cli.api.project.errors import SchemaValidationError
 from snowflake.cli.api.project.schemas.entities.common import (
     TargetField,
@@ -159,6 +165,12 @@ class DefinitionV20(_ProjectDefinitionBase):
                 target_object = entity.from_
                 target_type = target_object.get_type()
                 cls._validate_target_field(target_key, target_type, entities)
+        elif entity.type == ApplicationPackageEntityModel.get_type():
+            for child_entity in entity.children:
+                target_key = child_entity.target
+                cls._validate_target_field(
+                    target_key, ApplicationPackageChildrenTypes, entities
+                )
 
     @classmethod
     def _validate_target_field(
@@ -168,11 +180,20 @@ class DefinitionV20(_ProjectDefinitionBase):
             raise ValueError(f"No such target: {target_key}")
 
         # Validate the target type
-        actual_target_type = entities[target_key].__class__
-        if target_type and target_type is not actual_target_type:
-            raise ValueError(
-                f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
-            )
+        if target_type:
+            actual_target_type = entities[target_key].__class__
+            if get_origin(target_type) in (Union, UnionType):
+                if actual_target_type not in get_args(target_type):
+                    expected_types_str = ", ".join(
+                        [t.__name__ for t in get_args(target_type)]
+                    )
+                    raise ValueError(
+                        f"Target type mismatch. Expected one of [{expected_types_str}], got {actual_target_type.__name__}"
+                    )
+            elif target_type is not actual_target_type:
+                raise ValueError(
+                    f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
+                )
 
     @model_validator(mode="before")
     @classmethod
@@ -200,6 +221,7 @@ class DefinitionV20(_ProjectDefinitionBase):
                     mixin_defs=data["mixins"],
                 )
                 entities[entity_name] = merged_values
+
         return data
 
     @classmethod
@@ -241,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,
@@ -333,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/project/schemas/v1/streamlit/streamlit.py

@@ -27,7 +27,7 @@ class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):
         title="Stage in which the app’s artifacts will be stored", default="streamlit"
     )
     query_warehouse: str = Field(
-        title="Snowflake warehouse to host the app", default="streamlit"
+        title="Snowflake warehouse to host the app", default=None
     )
     main_file: Optional[Path] = Field(
         title="Entrypoint file of the Streamlit app", default="streamlit_app.py"