snowflake-cli-labs 3.0.0rc1__py3-none-any.whl → 3.0.0rc3__py3-none-any.whl

snowflake/cli/api/entities/utils.py

@@ -9,11 +9,9 @@ from snowflake.cli._plugins.nativeapp.artifacts import (
     BundleMap,
     resolve_without_follow,
 )
-from snowflake.cli._plugins.nativeapp.constants import OWNER_COL
 from snowflake.cli._plugins.nativeapp.exceptions import (
     InvalidTemplateInFileError,
     MissingScriptError,
-    UnexpectedOwnerError,
 )
 from snowflake.cli._plugins.nativeapp.utils import verify_exists, verify_no_directories
 from snowflake.cli._plugins.stage.diff import (
@@ -34,12 +32,12 @@ from snowflake.cli.api.errno import (
 )
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
-from snowflake.cli.api.project.util import unquote_identifier
 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.connector import ProgrammingError
+from snowflake.connector.cursor import SnowflakeCursor
 
 
 def generic_sql_error_handler(
@@ -79,17 +77,6 @@ def generic_sql_error_handler(
     raise err
 
 
-def ensure_correct_owner(row: dict, role: str, obj_name: str) -> None:
-    """
-    Check if an object has the right owner role
-    """
-    actual_owner = row[
-        OWNER_COL
-    ].upper()  # Because unquote_identifier() always returns uppercase str
-    if actual_owner != unquote_identifier(role):
-        raise UnexpectedOwnerError(obj_name, role, actual_owner)
-
-
 def _get_stage_paths_to_sync(
     local_paths_to_sync: List[Path], deploy_root: Path
 ) -> List[StagePath]:
@@ -303,27 +290,34 @@ def render_script_templates(
     - List of rendered scripts content
     Size of the return list is the same as the size of the input scripts list.
     """
-    scripts_contents = []
-    for relpath in scripts:
-        script_full_path = SecurePath(project_root) / relpath
-        try:
-            template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
-            env = override_env or choose_sql_jinja_env_based_on_template_syntax(
-                template_content, reference_name=relpath
-            )
-            result = env.from_string(template_content).render(jinja_context)
-            scripts_contents.append(result)
+    return [
+        render_script_template(project_root, jinja_context, script, override_env)
+        for script in scripts
+    ]
 
-        except FileNotFoundError as e:
-            raise MissingScriptError(relpath) from e
 
-        except jinja2.TemplateSyntaxError as e:
-            raise InvalidTemplateInFileError(relpath, e, e.lineno) from e
+def render_script_template(
+    project_root: Path,
+    jinja_context: dict[str, Any],
+    script: str,
+    override_env: Optional[jinja2.Environment] = None,
+) -> str:
+    script_full_path = SecurePath(project_root) / script
+    try:
+        template_content = script_full_path.read_text(file_size_limit_mb=UNLIMITED)
+        env = override_env or choose_sql_jinja_env_based_on_template_syntax(
+            template_content, reference_name=script
+        )
+        return env.from_string(template_content).render(jinja_context)
+
+    except FileNotFoundError as e:
+        raise MissingScriptError(script) from e
 
-        except jinja2.UndefinedError as e:
-            raise InvalidTemplateInFileError(relpath, e) from e
+    except jinja2.TemplateSyntaxError as e:
+        raise InvalidTemplateInFileError(script, e, e.lineno) from e
 
-    return scripts_contents
+    except jinja2.UndefinedError as e:
+        raise InvalidTemplateInFileError(script, e) from e
 
 
 def validation_item_to_str(item: dict[str, str | int]):
@@ -355,3 +349,19 @@ def drop_generic_object(
             raise SnowflakeSQLExecutionError(drop_query)
 
         console.message(f"Dropped {object_type} {object_name} successfully.")
+
+
+def print_messages(
+    console: AbstractConsole, create_or_upgrade_cursor: Optional[SnowflakeCursor]
+):
+    """
+    Shows messages in the console returned by the CREATE or UPGRADE
+    APPLICATION command.
+    """
+    if not create_or_upgrade_cursor:
+        return
+
+    messages = [row[0] for row in create_or_upgrade_cursor.fetchall()]
+    for message in messages:
+        console.warning(message)
+    console.message("")

snowflake/cli/api/errno.py

@@ -17,6 +17,7 @@ NO_WAREHOUSE_SELECTED_IN_SESSION = 606
 
 DOES_NOT_EXIST_OR_NOT_AUTHORIZED = 2003
 DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED = 2043
+INSUFFICIENT_PRIVILEGES = 3001
 
 # Native Apps
 CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION = 93044

snowflake/cli/api/identifiers.py

@@ -18,8 +18,7 @@ import re
 
 from click import ClickException
 from snowflake.cli.api.exceptions import FQNInconsistencyError, FQNNameError
-from snowflake.cli.api.project.schemas.identifier_model import (
-    Identifier,
+from snowflake.cli.api.project.schemas.v1.identifier_model import (
     ObjectIdentifierBaseModel,
 )
 from snowflake.cli.api.project.util import VALID_IDENTIFIER_REGEX, identifier_for_url
@@ -142,8 +141,10 @@ class FQN:
         return fqn.set_database(model.database).set_schema(model.schema_name)
 
     @classmethod
-    def from_identifier_model_v2(cls, model: Identifier) -> "FQN":
+    def from_identifier_model_v2(cls, model) -> "FQN":
         """Create an instance from object model."""
+        from snowflake.cli.api.project.schemas.entities.common import Identifier
+
         if not isinstance(model, Identifier):
             raise ClickException(f"Expected {type(Identifier).__name__}, got {model}.")
 
@@ -184,3 +185,6 @@ class FQN:
         from snowflake.cli.api.cli_global_context import get_cli_context
 
         return self.using_connection(get_cli_context().connection)
+
+    def to_dict(self) -> dict:
+        return {"name": self.name, "schema": self.schema, "database": self.database}

snowflake/cli/api/project/definition.py

@@ -23,6 +23,7 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.project_definition import (
     ProjectProperties,
+    YamlOverride,
 )
 from snowflake.cli.api.project.util import (
     append_to_identifier,
@@ -37,6 +38,7 @@ from snowflake.cli.api.utils.definition_rendering import (
 )
 from snowflake.cli.api.utils.dict_utils import deep_merge_dicts
 from snowflake.cli.api.utils.types import Context, Definition
+from yaml import MappingNode, SequenceNode
 
 DEFAULT_USERNAME = "unknown_user"
 
@@ -50,6 +52,7 @@ def _get_merged_definitions(paths: List[Path]) -> Optional[Definition]:
     loader.add_constructor(
         yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG, _no_duplicates_constructor
     )
+    loader.add_constructor("!override", _override_tag)
 
     with spaths[0].open("r", read_file_limit_mb=DEFAULT_SIZE_LIMIT_MB) as base_yml:
         definition = yaml.load(base_yml.read(), Loader=loader) or {}
@@ -113,3 +116,11 @@ def _no_duplicates_constructor(loader, node, deep=False):
             )
         mapping[key] = value
     return loader.construct_mapping(node, deep)
+
+
+def _override_tag(loader, node, deep=False):
+    if isinstance(node, SequenceNode):
+        return YamlOverride(data=loader.construct_sequence(node, deep))
+    if isinstance(node, MappingNode):
+        return YamlOverride(data=loader.construct_mapping(node, deep))
+    return node.value

snowflake/cli/api/project/definition_conversion.py

@@ -1,42 +1,66 @@
+from __future__ import annotations
+
 import logging
 from pathlib import Path
 from typing import Any, Dict, Literal, Optional
 
 from click import ClickException
+from snowflake.cli._plugins.nativeapp.artifacts import (
+    build_bundle,
+)
 from snowflake.cli._plugins.snowpark.common import is_name_a_templated_one
 from snowflake.cli.api.constants import (
     DEFAULT_ENV_FILE,
     DEFAULT_PAGES_DIR,
+    PROJECT_TEMPLATE_VARIABLE_CLOSING,
     PROJECT_TEMPLATE_VARIABLE_OPENING,
     SNOWPARK_SHARED_MIXIN,
 )
+from snowflake.cli.api.entities.utils import render_script_template
+from snowflake.cli.api.project.schemas.entities.common import (
+    SqlScriptHookType,
+)
 from snowflake.cli.api.project.schemas.project_definition import (
     ProjectDefinition,
     ProjectDefinitionV2,
 )
-from snowflake.cli.api.project.schemas.snowpark.callable import (
+from snowflake.cli.api.project.schemas.v1.native_app.application import (
+    Application,
+    ApplicationV11,
+)
+from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
+from snowflake.cli.api.project.schemas.v1.native_app.package import Package, PackageV11
+from snowflake.cli.api.project.schemas.v1.snowpark.callable import (
     FunctionSchema,
     ProcedureSchema,
 )
-from snowflake.cli.api.project.schemas.snowpark.snowpark import Snowpark
-from snowflake.cli.api.project.schemas.streamlit.streamlit import Streamlit
+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
 
 log = logging.getLogger(__name__)
 
 
 def convert_project_definition_to_v2(
-    pd: ProjectDefinition, accept_templates: bool = False
+    project_root: Path, pd: ProjectDefinition, accept_templates: bool = False
 ) -> ProjectDefinitionV2:
     _check_if_project_definition_meets_requirements(pd, 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 {}
+    native_app_data = (
+        convert_native_app_to_v2_data(project_root, pd.native_app)
+        if pd.native_app
+        else {}
+    )
     envs = convert_envs_to_v2(pd)
 
     data = {
         "definition_version": "2",
         "entities": get_list_of_all_entities(
-            snowpark_data.get("entities", {}), streamlit_data.get("entities", {})
+            snowpark_data.get("entities", {}),
+            streamlit_data.get("entities", {}),
+            native_app_data.get("entities", {}),
         ),
         "mixins": snowpark_data.get("mixins", None),
         "env": envs,
@@ -99,7 +123,7 @@ def convert_snowpark_to_v2_data(snowpark: Snowpark) -> Dict[str, Any]:
     return data
 
 
-def convert_streamlit_to_v2_data(streamlit: Streamlit):
+def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
     # Process env file and pages dir
     environment_file = _process_streamlit_files(streamlit.env_file, "environment")
     pages_dir = _process_streamlit_files(streamlit.pages_dir, "pages")
@@ -133,6 +157,7 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit):
                 "type": "streamlit",
                 "identifier": identifier,
                 "title": streamlit.title,
+                "comment": streamlit.comment,
                 "query_warehouse": streamlit.query_warehouse,
                 "main_file": str(streamlit.main_file),
                 "pages_dir": str(streamlit.pages_dir),
@@ -144,6 +169,135 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit):
     return data
 
 
+def convert_native_app_to_v2_data(
+    project_root, native_app: NativeApp
+) -> Dict[str, Any]:
+    def _make_meta(obj: Application | Package):
+        meta = {}
+        if obj.role:
+            meta["role"] = obj.role
+        if obj.warehouse:
+            meta["warehouse"] = obj.warehouse
+        if obj.post_deploy:
+            meta["post_deploy"] = obj.post_deploy
+        return meta
+
+    def _find_manifest():
+        # We don't know which file in the project directory is the actual manifest,
+        # and we can't iterate through the artifacts property since the src can contain
+        # glob patterns. The simplest solution is to bundle the app and find the
+        # manifest file from the resultant BundleMap, since the bundle process ensures
+        # that only a single source path can map to the corresponding destination path
+        try:
+            bundle_map = build_bundle(
+                project_root, Path(native_app.deploy_root), native_app.artifacts
+            )
+        except Exception as e:
+            # The manifest field is required, so we can't gracefully handle bundle failures
+            raise ClickException(
+                f"{e}\nCould not bundle Native App artifacts, unable to perform migration"
+            ) from e
+
+        manifest_path = bundle_map.to_project_path(Path("manifest.yml"))
+        if not manifest_path:
+            # The manifest field is required, so we can't gracefully handle it being missing
+            raise ClickException(
+                "manifest.yml file not found in any Native App artifact sources, "
+                "unable to perform migration"
+            )
+
+        # Use a POSIX path to be consistent with other migrated fields
+        # which use POSIX paths as default values
+        return manifest_path.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
+        and native_app.package.name
+        and native_app.package.name != PackageV11.model_fields["name"].default
+    ):
+        package_identifier = native_app.package.name
+    else:
+        # Backport the PackageV11 default name template, updated for PDFv2
+        package_identifier = _make_template(
+            f"fn.concat_ids('{native_app.name}', '_pkg_', fn.sanitize_id(fn.get_username('unknown_user')) | lower)"
+        )
+    package = {
+        "type": "application package",
+        "identifier": package_identifier,
+        "manifest": _find_manifest(),
+        "artifacts": native_app.artifacts,
+        "bundle_root": native_app.bundle_root,
+        "generated_root": native_app.generated_root,
+        "deploy_root": native_app.deploy_root,
+        "stage": native_app.source_stage,
+        "scratch_stage": native_app.scratch_stage,
+    }
+    if native_app.package:
+        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
+            )
+        if package_meta:
+            package["meta"] = package_meta
+
+    app_entity_name = "app"
+    if (
+        native_app.application
+        and native_app.application.name
+        and native_app.application.name != ApplicationV11.model_fields["name"].default
+    ):
+        app_identifier = native_app.application.name
+    else:
+        # Backport the ApplicationV11 default name template, updated for PDFv2
+        app_identifier = _make_template(
+            f"fn.concat_ids('{native_app.name}', '_', fn.sanitize_id(fn.get_username('unknown_user')) | lower)"
+        )
+    app = {
+        "type": "application",
+        "identifier": app_identifier,
+        "from": {"target": package_entity_name},
+    }
+    if native_app.application:
+        if app_meta := _make_meta(native_app.application):
+            app["meta"] = app_meta
+
+    return {
+        "entities": {
+            package_entity_name: package,
+            app_entity_name: app,
+        }
+    }
+
+
 def convert_envs_to_v2(pd: ProjectDefinition):
     if hasattr(pd, "env") and pd.env:
         data = {k: v for k, v in pd.env.items()}
@@ -166,10 +320,6 @@ def _check_if_project_definition_meets_requirements(
         log.warning(
             "Your V1 definition contains templates. We cannot guarantee the correctness of the migration."
         )
-    if pd.native_app:
-        raise ClickException(
-            "Your project file contains a native app definition. Conversion of Native apps is not yet supported"
-        )
 
 
 def _process_streamlit_files(
@@ -185,10 +335,19 @@ def _process_streamlit_files(
 
 
 def get_list_of_all_entities(
-    snowpark_entities: Dict[str, Any], streamlit_entities: Dict[str, Any]
+    snowpark_entities: Dict[str, Any],
+    streamlit_entities: Dict[str, Any],
+    native_app_entities: Dict[str, Any],
 ):
-    if snowpark_entities.keys() & streamlit_entities.keys():
-        raise ClickException(
-            "In your project, streamlit and snowpark entities share the same name. Please rename them and try again."
-        )
-    return snowpark_entities | streamlit_entities
+    # Check all combinations of entity types for overlapping names
+    # (No need to use itertools here, PDFv1 only supports these three types)
+    for types, first, second in [
+        ("streamlit and snowpark", streamlit_entities, snowpark_entities),
+        ("streamlit and native app", streamlit_entities, native_app_entities),
+        ("native app and snowpark", native_app_entities, snowpark_entities),
+    ]:
+        if first.keys() & second.keys():
+            raise ClickException(
+                f"In your project, {types} entities share the same name. Please rename them and try again."
+            )
+    return snowpark_entities | streamlit_entities | native_app_entities

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

@@ -15,11 +15,10 @@
 from __future__ import annotations
 
 from abc import ABC
-from typing import Generic, List, Optional, TypeVar, Union
+from typing import Dict, Generic, List, Optional, TypeVar, Union
 
 from pydantic import Field, PrivateAttr, field_validator
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.schemas.identifier_model import Identifier
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
     UpdatableModel,
@@ -61,16 +60,10 @@ class MetaField(UpdatableModel):
         return mixins
 
 
-class DefaultsField(UpdatableModel):
-    schema_: Optional[str] = Field(
-        title="Schema.",
-        alias="schema",
-        default=None,
-    )
-    stage: Optional[str] = Field(
-        title="Stage.",
-        default=None,
-    )
+class Identifier(UpdatableModel):
+    name: str = Field(title="Entity name")
+    schema_: Optional[str] = Field(title="Entity schema", alias="schema", default=None)
+    database: Optional[str] = Field(title="Entity database", default=None)
 
 
 class EntityModelBase(ABC, UpdatableModel):
@@ -124,9 +117,17 @@ class TargetField(UpdatableModel, Generic[TargetType]):
         return self.__pydantic_generic_metadata__["args"][0]
 
 
-from typing import Dict, List, Optional
+class ImportsBaseModel:
+    imports: Optional[List[str]] = Field(
+        title="Stage and path to previously uploaded files you want to import",
+        default=[],
+    )
 
-from pydantic import Field
+    def get_imports_sql(self) -> str | None:
+        if not self.imports:
+            return None
+        imports = ", ".join(f"'{i}'" for i in self.imports)
+        return f"IMPORTS = ({imports})"
 
 
 class ExternalAccessBaseModel:

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

@@ -16,23 +16,26 @@ from __future__ import annotations
 
 from typing import Dict, List, Union, get_args
 
-from snowflake.cli.api.entities.application_entity import ApplicationEntity
-from snowflake.cli.api.entities.application_package_entity import (
-    ApplicationPackageEntity,
-)
-from snowflake.cli.api.entities.snowpark_entity import FunctionEntity, ProcedureEntity
-from snowflake.cli.api.entities.streamlit_entity import StreamlitEntity
-from snowflake.cli.api.project.schemas.entities.application_entity_model import (
+from snowflake.cli._plugins.nativeapp.application_entity import ApplicationEntity
+from snowflake.cli._plugins.nativeapp.application_entity_model import (
     ApplicationEntityModel,
 )
-from snowflake.cli.api.project.schemas.entities.application_package_entity_model import (
+from snowflake.cli._plugins.nativeapp.application_package_entity import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli._plugins.nativeapp.application_package_entity_model import (
     ApplicationPackageEntityModel,
 )
-from snowflake.cli.api.project.schemas.entities.snowpark_entity import (
+from snowflake.cli._plugins.snowpark.snowpark_entity import (
+    FunctionEntity,
+    ProcedureEntity,
+)
+from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
     FunctionEntityModel,
     ProcedureEntityModel,
 )
-from snowflake.cli.api.project.schemas.entities.streamlit_entity_model import (
+from snowflake.cli._plugins.streamlit.streamlit_entity import StreamlitEntity
+from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )