snowflake-cli-labs 2.8.0rc1__py3-none-any.whl → 3.0.0__py3-none-any.whl

snowflake/cli/_plugins/nativeapp/codegen/templates/templates_processor.py

@@ -0,0 +1,114 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import jinja2
+from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
+from snowflake.cli._plugins.nativeapp.codegen.artifact_processor import (
+    ArtifactProcessor,
+)
+from snowflake.cli._plugins.nativeapp.exceptions import InvalidTemplateInFileError
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.metrics import CLICounterField
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import (
+    PathMapping,
+    ProcessorMapping,
+)
+from snowflake.cli.api.rendering.project_definition_templates import (
+    get_client_side_jinja_env,
+    has_client_side_templates,
+)
+from snowflake.cli.api.rendering.sql_templates import (
+    choose_sql_jinja_env_based_on_template_syntax,
+    has_sql_templates,
+)
+
+
+def _is_sql_file(file: Path) -> bool:
+    return file.name.lower().endswith(".sql")
+
+
+class TemplatesProcessor(ArtifactProcessor):
+    """
+    Processor class to perform template expansion on all relevant artifacts (specified in the project definition file).
+    """
+
+    def expand_templates_in_file(self, src: Path, dest: Path) -> None:
+        """
+        Expand templates in the file.
+        """
+        if src.is_dir():
+            return
+
+        with self.edit_file(dest) as file:
+            if not has_client_side_templates(file.contents) and not (
+                _is_sql_file(dest) and has_sql_templates(file.contents)
+            ):
+                return
+
+            src_file_name = src.relative_to(self._bundle_ctx.project_root)
+            cc.step(f"Expanding templates in {src_file_name}")
+            with cc.indented():
+                try:
+                    jinja_env = (
+                        choose_sql_jinja_env_based_on_template_syntax(
+                            file.contents, reference_name=src_file_name
+                        )
+                        if _is_sql_file(dest)
+                        else get_client_side_jinja_env()
+                    )
+                    expanded_template = jinja_env.from_string(file.contents).render(
+                        get_cli_context().template_context
+                    )
+
+                # For now, we are printing the source file path in the error message
+                # instead of the destination file path to make it easier for the user
+                # to identify the file that has the error, and edit the correct file.
+                except jinja2.TemplateSyntaxError as e:
+                    raise InvalidTemplateInFileError(src_file_name, e, e.lineno) from e
+
+                except jinja2.UndefinedError as e:
+                    raise InvalidTemplateInFileError(src_file_name, e) from e
+
+                if expanded_template != file.contents:
+                    file.edited_contents = expanded_template
+
+    def process(
+        self,
+        artifact_to_process: PathMapping,
+        processor_mapping: Optional[ProcessorMapping],
+        **kwargs,
+    ) -> None:
+        """
+        Process the artifact by executing the template expansion logic on it.
+        """
+
+        get_cli_context().metrics.set_counter(CLICounterField.TEMPLATES_PROCESSOR, 1)
+
+        bundle_map = BundleMap(
+            project_root=self._bundle_ctx.project_root,
+            deploy_root=self._bundle_ctx.deploy_root,
+        )
+        bundle_map.add(artifact_to_process)
+
+        for src, dest in bundle_map.all_mappings(
+            absolute=True,
+            expand_directories=True,
+        ):
+            self.expand_templates_in_file(src, dest)

snowflake/cli/{plugins → _plugins}/nativeapp/commands.py

@@ -14,60 +14,62 @@
 
 from __future__ import annotations
 
+import itertools
 import logging
+from enum import Enum
 from pathlib import Path
 from textwrap import dedent
-from typing import List, Optional
+from typing import Generator, Iterable, List, Optional, cast
 
 import typer
-from click import ClickException
-from snowflake.cli.api.cli_global_context import cli_context
-from snowflake.cli.api.commands.decorators import (
-    with_project_definition,
-)
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.output.formats import OutputFormat
-from snowflake.cli.api.output.types import (
-    CollectionResult,
-    CommandResult,
-    MessageResult,
-    ObjectResult,
-    StreamResult,
-)
-from snowflake.cli.api.project.project_verification import assert_project_type
-from snowflake.cli.api.secure_path import SecurePath
-from snowflake.cli.plugins.nativeapp.common_flags import (
+from click.exceptions import ClickException
+from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
     InteractiveOption,
     ValidateOption,
 )
-from snowflake.cli.plugins.nativeapp.init import (
-    OFFICIAL_TEMPLATES_GITHUB_URL,
-    nativeapp_init,
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
+    ApplicationPackageEntityModel,
 )
-from snowflake.cli.plugins.nativeapp.manager import NativeAppManager
-from snowflake.cli.plugins.nativeapp.policy import (
+from snowflake.cli._plugins.nativeapp.manager import NativeAppManager
+from snowflake.cli._plugins.nativeapp.policy import (
     AllowAlwaysPolicy,
     AskAlwaysPolicy,
     DenyAlwaysPolicy,
 )
-from snowflake.cli.plugins.nativeapp.run_processor import NativeAppRunProcessor
-from snowflake.cli.plugins.nativeapp.teardown_processor import (
+from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
+from snowflake.cli._plugins.nativeapp.teardown_processor import (
     NativeAppTeardownProcessor,
 )
-from snowflake.cli.plugins.nativeapp.utils import (
-    get_first_paragraph_from_markdown_file,
-    shallow_git_clone,
-)
-from snowflake.cli.plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
+from snowflake.cli._plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
+    find_entity,
     nativeapp_definition_v2_to_v1,
 )
-from snowflake.cli.plugins.nativeapp.version.commands import app as versions_app
-from snowflake.cli.plugins.stage.diff import (
+from snowflake.cli._plugins.nativeapp.version.commands import app as versions_app
+from snowflake.cli._plugins.stage.diff import (
     DiffResult,
     compute_stage_diff,
-    print_diff_to_console,
 )
+from snowflake.cli._plugins.stage.utils import print_diff_to_console
+from snowflake.cli._plugins.workspace.manager import WorkspaceManager
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.commands.decorators import (
+    with_project_definition,
+)
+from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
+from snowflake.cli.api.entities.common import EntityActions
+from snowflake.cli.api.exceptions import IncompatibleParametersError
+from snowflake.cli.api.output.formats import OutputFormat
+from snowflake.cli.api.output.types import (
+    CommandResult,
+    MessageResult,
+    ObjectResult,
+    StreamResult,
+)
+from snowflake.cli.api.project.project_verification import assert_project_type
+from snowflake.cli.api.project.schemas.project_definition import ProjectDefinitionV1
+from typing_extensions import Annotated
 
 app = SnowTyperFactory(
     name="app",
@@ -78,85 +80,20 @@ app.add_typer(versions_app)
 log = logging.getLogger(__name__)
 
 
-@app.command("init")
-def app_init(
-    path: str = typer.Argument(
-        ...,
-        help=f"""Directory to be initialized with the Snowflake Native App project. This directory must not already exist.""",
-    ),
-    name: str = typer.Option(
-        None,
-        help=f"""The name of the Snowflake Native App project to include in snowflake.yml. When not specified, it is
-        generated from the name of the directory. Names are assumed to be unquoted identifiers whenever possible, but
-        can be forced to be quoted by including the surrounding quote characters in the provided value.""",
-    ),
-    template_repo: str = typer.Option(
-        None,
-        help=f"""Specifies the git URL to a template repository, which can be a template itself or contain many templates inside it,
-        such as https://github.com/snowflakedb/native-apps-templates.git for all official Snowflake Native App with Snowflake CLI templates.
-        If using a private Github repo, you might be prompted to enter your Github username and password.
-        Please use your personal access token in the password prompt, and refer to
-        https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.""",
-    ),
-    template: str = typer.Option(
-        None,
-        help="A specific template name within the template repo to use as template for the Snowflake Native App project. Example: Default is basic if `--template-repo` is https://github.com/snowflakedb/native-apps-templates.git, and None if any other --template-repo is specified.",
-    ),
-    **options,
-) -> CommandResult:
-    """
-    Initializes a Snowflake Native App project.
+@app.command("init", hidden=True)
+def app_init(**options):
     """
-    project = nativeapp_init(
-        path=path, name=name, git_url=template_repo, template=template
-    )
-    return MessageResult(
-        f"Snowflake Native App project {project.name} has been created at: {path}"
-    )
-
+    *** Deprecated. Use snow init instead ***
 
-@app.command("list-templates", hidden=True)
-def app_list_templates(**options) -> CommandResult:
-    """
-    Prints information regarding the official templates that can be used with snow app init.
+    Initializes a Snowflake Native App project.
     """
-    with SecurePath.temporary_directory() as temp_path:
-        from git import rmtree as git_rmtree
-
-        repo = shallow_git_clone(OFFICIAL_TEMPLATES_GITHUB_URL, temp_path.path)
-
-        # Mark a directory as a template if a project definition jinja template is inside
-        template_directories = [
-            entry.name
-            for entry in repo.head.commit.tree
-            if (temp_path / entry.name / "snowflake.yml.jinja").exists()
-        ]
-
-        # get the template descriptions from the README.md in its directory
-        template_descriptions = [
-            get_first_paragraph_from_markdown_file(
-                (temp_path / directory / "README.md").path
-            )
-            for directory in template_directories
-        ]
-
-        result = (
-            {"template": directory, "description": description}
-            for directory, description in zip(
-                template_directories, template_descriptions
-            )
-        )
-
-        # proactively clean up here to avoid permission issues on Windows
-        repo.close()
-        git_rmtree(temp_path.path)
 
-        return CollectionResult(result)
+    raise ClickException("This command has been removed. Use `snow init` instead.")
 
 
 @app.command("bundle")
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1()
 def app_bundle(
     **options,
 ) -> CommandResult:
@@ -166,6 +103,7 @@ def app_bundle(
 
     assert_project_type("native_app")
 
+    cli_context = get_cli_context()
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -176,7 +114,7 @@ def app_bundle(
 
 @app.command("diff", requires_connection=True, hidden=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1()
 def app_diff(
     **options,
 ) -> CommandResult:
@@ -185,6 +123,7 @@ def app_diff(
     """
     assert_project_type("native_app")
 
+    cli_context = get_cli_context()
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -202,7 +141,7 @@ def app_diff(
 
 @app.command("run", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1(app_required=True)
 def app_run(
     version: Optional[str] = typer.Option(
         None,
@@ -243,6 +182,7 @@ def app_run(
     else:
         policy = DenyAlwaysPolicy()
 
+    cli_context = get_cli_context()
     processor = NativeAppRunProcessor(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -265,7 +205,7 @@ def app_run(
 
 @app.command("open", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1(app_required=True)
 def app_open(
     **options,
 ) -> CommandResult:
@@ -276,6 +216,7 @@ def app_open(
 
     assert_project_type("native_app")
 
+    cli_context = get_cli_context()
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -291,7 +232,9 @@ def app_open(
 
 @app.command("teardown", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+# This command doesn't use @nativeapp_definition_v2_to_v1 because it needs to
+# be aware of PDFv2 definitions that have multiple apps created from the same package,
+# which all need to be torn down.
 def app_teardown(
     force: Optional[bool] = ForceOption,
     cascade: Optional[bool] = typer.Option(
@@ -300,25 +243,70 @@ def app_teardown(
         show_default=False,
     ),
     interactive: bool = InteractiveOption,
+    # Same as the param auto-added by @nativeapp_definition_v2_to_v1
+    package_entity_id: Optional[str] = typer.Option(
+        default="",
+        help="The ID of the package entity on which to operate when definition_version is 2 or higher.",
+    ),
     **options,
 ) -> CommandResult:
     """
     Attempts to drop both the application object and application package as defined in the project definition file.
     """
+    cli_context = get_cli_context()
+    project = cli_context.project_definition
+    if isinstance(project, ProjectDefinitionV1):
+        # Old behaviour, not multi-app aware so we can use the old processor
+        processor = NativeAppTeardownProcessor(
+            project_definition=cli_context.project_definition.native_app,
+            project_root=cli_context.project_root,
+        )
+        processor.process(interactive, force, cascade)
+    else:
+        # New behaviour, multi-app aware so teardown all the apps created from the package
+
+        # Determine the package entity to drop, there must be one
+        app_package_entity = find_entity(
+            project,
+            ApplicationPackageEntityModel,
+            package_entity_id,
+            disambiguation_option="--package-entity-id",
+            required=True,
+        )
+        assert app_package_entity is not None  # satisfy mypy
 
-    assert_project_type("native_app")
+        # Same implementation as `snow ws drop`
+        ws = WorkspaceManager(
+            project_definition=cli_context.project_definition,
+            project_root=cli_context.project_root,
+        )
+        for app_entity in project.get_entities_by_type(
+            ApplicationEntityModel.get_type()
+        ).values():
+            # Drop each app
+            if app_entity.from_.target == app_package_entity.entity_id:
+                ws.perform_action(
+                    app_entity.entity_id,
+                    EntityActions.DROP,
+                    force_drop=force,
+                    interactive=interactive,
+                    cascade=cascade,
+                )
+        # Then drop the package
+        ws.perform_action(
+            app_package_entity.entity_id,
+            EntityActions.DROP,
+            force_drop=force,
+            interactive=interactive,
+            cascade=cascade,
+        )
 
-    processor = NativeAppTeardownProcessor(
-        project_definition=cli_context.project_definition.native_app,
-        project_root=cli_context.project_root,
-    )
-    processor.process(interactive, force, cascade)
     return MessageResult(f"Teardown is now complete.")
 
 
 @app.command("deploy", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
+@nativeapp_definition_v2_to_v1()
 def app_deploy(
     prune: Optional[bool] = typer.Option(
         default=None,
@@ -341,6 +329,8 @@ def app_deploy(
             unspecified, the command syncs all local changes to the stage."""
         ).strip(),
     ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
     validate: bool = ValidateOption,
     **options,
 ) -> CommandResult:
@@ -351,6 +341,13 @@ def app_deploy(
 
     assert_project_type("native_app")
 
+    if force:
+        policy = AllowAlwaysPolicy()
+    elif interactive:
+        policy = AskAlwaysPolicy()
+    else:
+        policy = DenyAlwaysPolicy()
+
     has_paths = paths is not None and len(paths) > 0
     if prune is None and recursive is None and not has_paths:
         prune = True
@@ -362,8 +359,9 @@ def app_deploy(
             recursive = False
 
     if has_paths and prune:
-        raise ClickException("--prune cannot be used when paths are also specified")
+        raise IncompatibleParametersError(["paths", "--prune"])
 
+    cli_context = get_cli_context()
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -376,6 +374,7 @@ def app_deploy(
         recursive=recursive,
         local_paths_to_sync=paths,
         validate=validate,
+        policy=policy,
     )
 
     return MessageResult(
@@ -385,14 +384,17 @@ def app_deploy(
 
 @app.command("validate", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
-def app_validate(**options):
+@nativeapp_definition_v2_to_v1()
+def app_validate(
+    **options,
+):
     """
     Validates a deployed Snowflake Native App's setup script.
     """
 
     assert_project_type("native_app")
 
+    cli_context = get_cli_context()
     manager = NativeAppManager(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
@@ -404,26 +406,144 @@ def app_validate(**options):
     return MessageResult("Snowflake Native App validation succeeded.")
 
 
-@app.command("events", hidden=True, requires_connection=True)
+class RecordType(Enum):
+    LOG = "log"
+    SPAN = "span"
+    SPAN_EVENT = "span_event"
+
+
+# The default number of lines to print before streaming when running
+# snow app events --follow
+DEFAULT_EVENT_FOLLOW_LAST = 20
+
+
+@app.command("events", requires_connection=True)
 @with_project_definition()
-@nativeapp_definition_v2_to_v1
-def app_events(**options):
-    """Fetches events for this app from the event table configured in Snowflake."""
+@nativeapp_definition_v2_to_v1(app_required=True)
+def app_events(
+    since: str = typer.Option(
+        default="",
+        help="Fetch events that are newer than this time ago, in Snowflake interval syntax.",
+    ),
+    until: str = typer.Option(
+        default="",
+        help="Fetch events that are older than this time ago, in Snowflake interval syntax.",
+    ),
+    record_types: Annotated[
+        list[RecordType], typer.Option(case_sensitive=False)
+    ] = typer.Option(
+        [],
+        "--type",
+        help="Restrict results to specific record type. Can be specified multiple times.",
+    ),
+    scopes: Annotated[list[str], typer.Option()] = typer.Option(
+        [],
+        "--scope",
+        help="Restrict results to a specific scope name. Can be specified multiple times.",
+    ),
+    consumer_org: str = typer.Option(
+        default="", help="The name of the consumer organization."
+    ),
+    consumer_account: str = typer.Option(
+        default="",
+        help="The name of the consumer account in the organization.",
+    ),
+    consumer_app_hash: str = typer.Option(
+        default="",
+        help="The SHA-1 hash of the consumer application name",
+    ),
+    first: int = typer.Option(
+        default=-1,
+        show_default=False,
+        help="Fetch only the first N events. Cannot be used with --last.",
+    ),
+    last: int = typer.Option(
+        default=-1,
+        show_default=False,
+        help="Fetch only the last N events. Cannot be used with --first.",
+    ),
+    follow: bool = typer.Option(
+        False,
+        "--follow",
+        "-f",
+        help=(
+            f"Continue polling for events. Implies --last {DEFAULT_EVENT_FOLLOW_LAST} "
+            f"unless overridden or the --since flag is used."
+        ),
+    ),
+    follow_interval: int = typer.Option(
+        10,
+        help=f"Polling interval in seconds when using the --follow flag.",
+    ),
+    **options,
+):
+    """Fetches events for this app from the event table configured in Snowflake.
+
+    By default, this command will fetch events generated by an app installed in the
+    current connection's account. To fetch events generated by an app installed
+    in a consumer account, use the --consumer-org and --consumer-account options.
+    This requires event sharing to be set up to route events to the provider account:
+    https://docs.snowflake.com/en/developer-guide/native-apps/setting-up-logging-and-events
+    """
+    if first >= 0 and last >= 0:
+        raise IncompatibleParametersError(["--first", "--last"])
+
+    if (consumer_org and not consumer_account) or (
+        consumer_account and not consumer_org
+    ):
+        raise IncompatibleParametersError(["--consumer-org", "--consumer-account"])
+
+    if follow:
+        if until:
+            raise IncompatibleParametersError(["--follow", "--until"])
+        if first >= 0:
+            raise IncompatibleParametersError(["--follow", "--first"])
+
     assert_project_type("native_app")
 
+    record_type_names = [r.name for r in record_types]
     manager = NativeAppManager(
-        project_definition=cli_context.project_definition.native_app,
-        project_root=cli_context.project_root,
+        project_definition=get_cli_context().project_definition.native_app,
+        project_root=get_cli_context().project_root,
     )
-    events = manager.get_events()
-    if not events:
-        return MessageResult("No events found.")
-
-    def g():
-        for event in events:
-            yield EventResult(event)
+    if follow:
+        if last == -1 and not since:
+            # If we don't have a value for --last or --since, assume a value
+            # for --last so we at least print something before starting the stream
+            last = DEFAULT_EVENT_FOLLOW_LAST
+        stream: Iterable[CommandResult] = (
+            EventResult(event)
+            for event in manager.stream_events(
+                since=since,
+                last=last,
+                interval_seconds=follow_interval,
+                record_types=record_type_names,
+                scopes=scopes,
+                consumer_org=consumer_org,
+                consumer_account=consumer_account,
+                consumer_app_hash=consumer_app_hash,
+            )
+        )
+        # Append a newline at the end to make the CLI output clean when we hit Ctrl-C
+        stream = itertools.chain(stream, [MessageResult("")])
+    else:
+        stream = (
+            EventResult(event)
+            for event in manager.get_events(
+                since=since,
+                until=until,
+                record_types=record_type_names,
+                scopes=scopes,
+                first=first,
+                last=last,
+                consumer_org=consumer_org,
+                consumer_account=consumer_account,
+                consumer_app_hash=consumer_app_hash,
+            )
+        )
 
-    return StreamResult(g())
+    # Cast the stream to a Generator since that's what StreamResult wants
+    return StreamResult(cast(Generator[CommandResult, None, None], stream))
 
 
 class EventResult(ObjectResult, MessageResult):

snowflake/cli/{plugins → _plugins}/nativeapp/common_flags.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import typer
-from snowflake.cli.plugins.nativeapp.utils import is_tty_interactive
+from snowflake.cli._plugins.nativeapp.utils import is_tty_interactive
 
 
 def interactive_callback(val):