snowflake-cli-labs 2.6.0rc0__py3-none-any.whl → 2.7.0rc0__py3-none-any.whl

snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "2.6.0rc0"
+VERSION = "2.7.0rc0"

snowflake/cli/api/cli_global_context.py

@@ -47,6 +47,7 @@ class _ConnectionContext:
         self._temporary_connection: bool = False
         self._session_token: Optional[str] = None
         self._master_token: Optional[str] = None
+        self._token_file_path: Optional[Path] = None
 
     def __setattr__(self, key, value):
         """
@@ -182,6 +183,13 @@ class _ConnectionContext:
     def set_master_token(self, value: Optional[str]):
         self._master_token = value
 
+    @property
+    def token_file_path(self) -> Optional[Path]:
+        return self._token_file_path
+
+    def set_token_file_path(self, value: Optional[Path]):
+        self._token_file_path = value
+
     @property
     def connection(self) -> SnowflakeConnection:
         if not self._cached_connection:
@@ -201,6 +209,7 @@ class _ConnectionContext:
             "warehouse": self.warehouse,
             "session_token": self.session_token,
             "master_token": self.master_token,
+            "token_file_path": self.token_file_path,
         }
 
     def _build_connection(self):

snowflake/cli/api/commands/decorators.py

@@ -39,6 +39,7 @@ from snowflake.cli.api.commands.flags import (
     SessionTokenOption,
     SilentOption,
     TemporaryConnectionOption,
+    TokenFilePathOption,
     UserOption,
     VerboseOption,
     WarehouseOption,
@@ -73,9 +74,7 @@ def global_options_with_connection(func: Callable):
     )
 
 
-def with_project_definition(
-    project_name: Optional[str] = None, is_optional: bool = False
-):
+def with_project_definition(is_optional: bool = False):
     def _decorator(func: Callable):
 
         return _options_decorator_factory(
@@ -85,7 +84,7 @@ def with_project_definition(
                     "project_definition",
                     inspect.Parameter.KEYWORD_ONLY,
                     annotation=Optional[str],
-                    default=project_definition_option(project_name, is_optional),
+                    default=project_definition_option(is_optional),
                 ),
                 inspect.Parameter(
                     "env_overrides",
@@ -252,6 +251,12 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=MasterTokenOption,
     ),
+    inspect.Parameter(
+        "token_file_path",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=TokenFilePathOption,
+    ),
     inspect.Parameter(
         "database",
         inspect.Parameter.KEYWORD_ONLY,

snowflake/cli/api/commands/execution_metadata.py

@@ -0,0 +1,40 @@
+# 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.
+import time
+import uuid
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class ExecutionStatus(Enum):
+    SUCCESS = "success"
+    FAILURE = "failure"
+
+
+@dataclass
+class ExecutionMetadata:
+    start_time: float = 0.0
+    end_time: float = 0.0
+    status: ExecutionStatus = ExecutionStatus.SUCCESS
+    execution_id: str = field(default_factory=lambda: uuid.uuid4().hex)
+
+    def __post_init__(self):
+        self.start_time = time.monotonic()
+
+    def complete(self, status: ExecutionStatus):
+        self.end_time = time.monotonic()
+        self.status = status
+
+    def get_duration(self):
+        return self.end_time - self.start_time

snowflake/cli/api/commands/flags.py

@@ -27,10 +27,10 @@ from click import ClickException
 from snowflake.cli.api.cli_global_context import cli_context_manager
 from snowflake.cli.api.commands.typer_pre_execute import register_pre_execute_command
 from snowflake.cli.api.console import cli_console
-from snowflake.cli.api.exceptions import MissingConfiguration, NoProjectDefinitionError
+from snowflake.cli.api.exceptions import MissingConfiguration
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.project.definition_manager import DefinitionManager
-from snowflake.cli.api.utils.rendering import CONTEXT_KEY
+from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
 
 DEFAULT_CONTEXT_SETTINGS = {"help_option_names": ["--help", "-h"]}
 
@@ -140,6 +140,9 @@ class OverrideableOption:
         return generated_callback
 
 
+from snowflake.cli.api.config import get_all_connections
+
+
 def _callback(provide_setter: Callable[[], Callable[[Any], Any]]):
     def callback(value):
         set_value = provide_setter()
@@ -160,6 +163,7 @@ ConnectionOption = typer.Option(
     ),
     show_default=False,
     rich_help_panel=_CONNECTION_SECTION,
+    autocompletion=lambda: list(get_all_connections()),
 )
 
 TemporaryConnectionOption = typer.Option(
@@ -272,6 +276,20 @@ MasterTokenOption = typer.Option(
     hidden=True,
 )
 
+TokenFilePathOption = typer.Option(
+    None,
+    "--token-file-path",
+    help="Path to file with an OAuth token that should be used when connecting to Snowflake",
+    callback=_callback(
+        lambda: cli_context_manager.connection_context.set_token_file_path
+    ),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+    exists=True,
+    file_okay=True,
+    dir_okay=False,
+)
+
 DatabaseOption = typer.Option(
     None,
     "--database",
@@ -429,12 +447,24 @@ OnErrorOption = typer.Option(
     help="What to do when an error occurs. Defaults to break.",
 )
 
-VariablesOption = typer.Option(
-    None,
-    "--variable",
-    "-D",
-    help="Variables for the template. For example: `-D \"<key>=<value>\"`, string values must be in `''`.",
-    show_default=False,
+NoInteractiveOption = typer.Option(False, "--no-interactive", help="Disable prompting.")
+
+
+def variables_option(description: str):
+    return typer.Option(
+        None,
+        "--variable",
+        "-D",
+        help=description,
+        show_default=False,
+    )
+
+
+ExecuteVariablesOption = variables_option(
+    'Variables for the execution context. For example: `-D "<key>=<value>"`. '
+    "For SQL files variables are use to expand the template and any unknown variable will cause an error. "
+    "For Python files variables are used to update os.environ dictionary. Provided keys are capitalized to adhere to best practices."
+    "In case of SQL files string values must be quoted in `''` (consider embedding quoting in the file).",
 )
 
 
@@ -500,7 +530,7 @@ def execution_identifier_argument(sf_object: str, example: str) -> typer.Argumen
     )
 
 
-def register_project_definition(project_name: Optional[str], is_optional: bool) -> None:
+def register_project_definition(is_optional: bool) -> None:
     project_path = cli_context_manager.project_path_arg
     env_overrides_args = cli_context_manager.project_env_overrides_args
 
@@ -514,42 +544,21 @@ def register_project_definition(project_name: Optional[str], is_optional: bool)
             "Cannot find project definition (snowflake.yml). Please provide a path to the project or run this command in a valid project directory."
         )
 
-    if project_name is not None and not getattr(project_definition, project_name, None):
-        raise NoProjectDefinitionError(
-            project_type=project_name, project_file=project_path
-        )
-
     cli_context_manager.set_project_definition(project_definition)
     cli_context_manager.set_project_root(project_root)
     cli_context_manager.set_template_context(template_context)
 
 
-def _get_project_long_name(project_short_name: Optional[str]) -> str:
-    if project_short_name is None:
-        return "Snowflake"
-
-    if project_short_name == "native_app":
-        project_long_name = "Snowflake Native App"
-    elif project_short_name == "streamlit":
-        project_long_name = "Streamlit app"
-    else:
-        project_long_name = project_short_name.replace("_", " ").capitalize()
-
-    return f"the {project_long_name}"
-
-
-def project_definition_option(project_name: Optional[str], is_optional: bool):
+def project_definition_option(is_optional: bool):
     def project_definition_callback(project_path: str) -> None:
         cli_context_manager.set_project_path_arg(project_path)
-        register_pre_execute_command(
-            lambda: register_project_definition(project_name, is_optional)
-        )
+        register_pre_execute_command(lambda: register_project_definition(is_optional))
 
     return typer.Option(
         None,
         "-p",
         "--project",
-        help=f"Path where {_get_project_long_name(project_name)} project resides. "
+        help=f"Path where Snowflake project resides. "
         f"Defaults to current working directory.",
         callback=_callback(lambda: project_definition_callback),
         show_default=False,
@@ -617,11 +626,11 @@ class Variable:
 
 def parse_key_value_variables(variables: Optional[List[str]]) -> List[Variable]:
     """Util for parsing key=value input. Useful for commands accepting multiple input options."""
+    if not variables:
+        return []
     result: List[Variable] = []
-
-    if variables is None:
+    if not variables:
         return result
-
     for p in variables:
         if "=" not in p:
             raise ClickException(f"Invalid variable: '{p}'")

snowflake/cli/api/commands/project_initialisation.py

@@ -35,7 +35,7 @@ def add_init_command(
     template: str,
     help_message: Optional[str] = None,
 ):
-    @app.command()
+    @app.command(deprecated=True)
     def init(
         project_name: str = Argument(
             f"example_{project_type.lower()}",
@@ -47,6 +47,7 @@ def add_init_command(
         ),
         **options,
     ) -> CommandResult:
+
         _create_project_template(template, project_directory=project_name)
         return MessageResult(f"Initialized the new project in {project_name}/")
 
@@ -57,6 +58,8 @@ def add_init_command(
     init.__doc__ = (
         f"Initializes this directory with a sample set "
         f"of files for creating a {project_type_doc} project."
+        f"This command is deprecated and will be removed soon."
+        f"Please use 'snow init' instead"
     )
 
     return init

snowflake/cli/api/commands/snow_typer.py

@@ -24,6 +24,10 @@ from snowflake.cli.api.commands.decorators import (
     global_options,
     global_options_with_connection,
 )
+from snowflake.cli.api.commands.execution_metadata import (
+    ExecutionMetadata,
+    ExecutionStatus,
+)
 from snowflake.cli.api.commands.flags import DEFAULT_CONTEXT_SETTINGS
 from snowflake.cli.api.commands.typer_pre_execute import run_pre_execute_commands
 from snowflake.cli.api.exceptions import CommandReturnTypeError
@@ -91,15 +95,18 @@ class SnowTyper(typer.Typer):
             @wraps(command_callable)
             def command_callable_decorator(*args, **kw):
                 """Wrapper around command callable. This is what happens at "runtime"."""
-                self.pre_execute()
+                execution = ExecutionMetadata()
+                self.pre_execute(execution)
                 try:
                     result = command_callable(*args, **kw)
-                    return self.process_result(result)
+                    self.process_result(result)
+                    execution.complete(ExecutionStatus.SUCCESS)
                 except Exception as err:
-                    self.exception_handler(err)
+                    execution.complete(ExecutionStatus.FAILURE)
+                    self.exception_handler(err, execution)
                     raise
                 finally:
-                    self.post_execute()
+                    self.post_execute(execution)
 
             return super(SnowTyper, self).command(name=name, **kwargs)(
                 command_callable_decorator
@@ -108,7 +115,7 @@ class SnowTyper(typer.Typer):
         return custom_command
 
     @staticmethod
-    def pre_execute():
+    def pre_execute(execution: ExecutionMetadata):
         """
         Callback executed before running any command callable (after context execution).
         Pay attention to make this method safe to use if performed operations are not necessary
@@ -118,7 +125,7 @@ class SnowTyper(typer.Typer):
 
         log.debug("Executing command pre execution callback")
         run_pre_execute_commands()
-        log_command_usage()
+        log_command_usage(execution)
 
     @staticmethod
     def process_result(result):
@@ -134,21 +141,25 @@ class SnowTyper(typer.Typer):
         print_result(result)
 
     @staticmethod
-    def exception_handler(exception: Exception):
+    def exception_handler(exception: Exception, execution: ExecutionMetadata):
         """
         Callback executed on command execution error.
         """
+        from snowflake.cli.app.telemetry import log_command_execution_error
+
         log.debug("Executing command exception callback")
+        log_command_execution_error(exception, execution)
 
     @staticmethod
-    def post_execute():
+    def post_execute(execution: ExecutionMetadata):
         """
         Callback executed after running any command callable. Pay attention to make this method safe to
         use if performed operations are not necessary for executing the command in proper way.
         """
-        from snowflake.cli.app.telemetry import flush_telemetry
+        from snowflake.cli.app.telemetry import flush_telemetry, log_command_result
 
         log.debug("Executing command post execution callback")
+        log_command_result(execution)
         flush_telemetry()
 
 

snowflake/cli/api/config.py

@@ -114,6 +114,8 @@ def config_init(config_file: Optional[Path]):
     Initializes the app configuration. Config provided via cli flag takes precedence.
     If config file does not exist we create an empty one.
     """
+    from snowflake.cli.app.loggers import create_initial_loggers
+
     if config_file:
         CONFIG_MANAGER.file_path = config_file
     else:
@@ -121,6 +123,7 @@ def config_init(config_file: Optional[Path]):
     if not CONFIG_MANAGER.file_path.exists():
         _initialise_config(CONFIG_MANAGER.file_path)
     _read_config_file()
+    create_initial_loggers()
 
 
 def add_connection(name: str, connection_config: ConnectionConfig):

snowflake/cli/api/errno.py

@@ -0,0 +1,27 @@
+# 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.
+
+# General errors
+NO_WAREHOUSE_SELECTED_IN_SESSION = 606
+
+DOES_NOT_EXIST_OR_NOT_AUTHORIZED = 2003
+DOES_NOT_EXIST_OR_CANNOT_BE_PERFORMED = 2043
+
+# Native Apps
+CANNOT_UPGRADE_FROM_LOOSE_FILES_TO_VERSION = 93044
+CANNOT_UPGRADE_FROM_VERSION_TO_LOOSE_FILES = 93045
+ONLY_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93046
+NOT_SUPPORTED_ON_DEV_MODE_APPLICATIONS = 93055
+APPLICATION_NO_LONGER_AVAILABLE = 93079
+APPLICATION_OWNS_EXTERNAL_OBJECTS = 93128

snowflake/cli/api/feature_flags.py

@@ -48,3 +48,4 @@ class FeatureFlag(FeatureFlagMixin):
     ENABLE_STREAMLIT_EMBEDDED_STAGE = BooleanFlag(
         "ENABLE_STREAMLIT_EMBEDDED_STAGE", False
     )
+    ENABLE_PROJECT_DEFINITION_V2 = BooleanFlag("ENABLE_PROJECT_DEFINITION_V2", False)

snowflake/cli/api/identifiers.py

@@ -53,17 +53,27 @@ class FQN:
         return self._name
 
     @property
-    def identifier(self) -> str:
+    def prefix(self) -> str:
         if self.database:
-            return f"{self.database}.{self.schema if self.schema else 'PUBLIC'}.{self.name}"
+            return f"{self.database}.{self.schema if self.schema else 'PUBLIC'}"
         if self.schema:
-            return f"{self.schema}.{self.name}"
+            return f"{self.schema}"
+        return ""
+
+    @property
+    def identifier(self) -> str:
+        if self.prefix:
+            return f"{self.prefix}.{self.name}"
         return self.name
 
     @property
     def url_identifier(self) -> str:
         return ".".join(identifier_for_url(part) for part in self.identifier.split("."))
 
+    @property
+    def sql_identifier(self) -> str:
+        return f"IDENTIFIER('{self.identifier}')"
+
     def __str__(self):
         return self.identifier
 
@@ -92,6 +102,13 @@ class FQN:
             unqualified_name = unqualified_name + signature
         return cls(name=unqualified_name, schema=schema, database=database)
 
+    @classmethod
+    def from_stage(cls, stage: str) -> "FQN":
+        name = stage
+        if stage.startswith("@"):
+            name = stage[1:]
+        return cls.from_string(name)
+
     @classmethod
     def from_identifier_model(cls, model: ObjectIdentifierBaseModel) -> "FQN":
         """Create an instance from object model."""

snowflake/cli/api/output/types.py

@@ -57,6 +57,15 @@ class MultipleResults(CommandResult):
         return (element for element in self._elements)
 
 
+class StreamResult(CommandResult):
+    def __init__(self, generator: t.Generator[CommandResult, None, None]):
+        self._generator = generator
+
+    @property
+    def result(self):
+        return self._generator
+
+
 class QueryResult(CollectionResult):
     def __init__(self, cursor: SnowflakeCursor | DictCursor):
         self.column_names = [col.name for col in cursor.description]

snowflake/cli/api/project/definition_manager.py

@@ -20,7 +20,7 @@ from pathlib import Path
 from typing import List, Optional
 
 from snowflake.cli.api.project.definition import ProjectProperties, load_project
-from snowflake.cli.api.project.schemas.project_definition import ProjectDefinition
+from snowflake.cli.api.project.schemas.project_definition import ProjectDefinitionV1
 from snowflake.cli.api.utils.types import Context
 
 
@@ -126,7 +126,7 @@ class DefinitionManager:
         return load_project(self._project_config_paths, self._context_overrides)
 
     @functools.cached_property
-    def project_definition(self) -> ProjectDefinition:
+    def project_definition(self) -> ProjectDefinitionV1:
         return self._project_properties.project_definition
 
     @functools.cached_property

snowflake/cli/api/project/project_verification.py

@@ -0,0 +1,23 @@
+# 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 snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.exceptions import NoProjectDefinitionError
+
+
+def assert_project_type(project_type: str):
+    if not getattr(cli_context.project_definition, project_type, None):
+        raise NoProjectDefinitionError(
+            project_type=project_type, project_file=cli_context.project_root
+        )

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

@@ -0,0 +1,50 @@
+# 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 typing import Literal, Optional
+
+from pydantic import AliasChoices, Field
+from snowflake.cli.api.project.schemas.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityBase,
+    TargetField,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    UpdatableModel,
+)
+
+
+class ApplicationEntity(EntityBase):
+    type: Literal["application"]  # noqa: A003
+    name: str = Field(
+        title="Name of the application created when this entity is deployed"
+    )
+    from_: ApplicationFromField = Field(
+        validation_alias=AliasChoices("from"),
+        title="An application package this entity should be created from",
+    )
+    debug: Optional[bool] = Field(
+        title="Whether to enable debug mode when using a named stage to create an application object",
+        default=None,
+    )
+
+
+class ApplicationFromField(UpdatableModel):
+    target: TargetField[ApplicationPackageEntity] = Field(
+        title="Reference to an application package entity",
+    )

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

@@ -0,0 +1,63 @@
+# 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 List, Literal, Optional, Union
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.entities.common import (
+    EntityBase,
+)
+from snowflake.cli.api.project.schemas.native_app.package import DistributionOptions
+from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
+from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
+
+
+class ApplicationPackageEntity(EntityBase):
+    type: Literal["application package"]  # noqa: A003
+    name: str = Field(
+        title="Name of the application package created when this entity is deployed"
+    )
+    artifacts: List[Union[PathMapping, Path]] = Field(
+        title="List of paths or file source/destination pairs to add to the deploy root",
+    )
+    bundle_root: Optional[Path] = Field(
+        title="Folder at the root of your project where artifacts necessary to perform the bundle step are stored.",
+        default=Path("output/bundle/"),
+    )
+    deploy_root: Optional[Path] = Field(
+        title="Folder at the root of your project where the build step copies the artifacts",
+        default=Path("output/deploy/"),
+    )
+    generated_root: Optional[Path] = Field(
+        title="Subdirectory of the deploy root where files generated by the Snowflake CLI will be written.",
+        default=Path("__generated/"),
+    )
+    stage: Optional[str] = IdentifierField(
+        title="Identifier of the stage that stores the application artifacts.",
+        default="app_src.stage",
+    )
+    scratch_stage: Optional[str] = IdentifierField(
+        title="Identifier of the stage that stores temporary scratch data used by the Snowflake CLI.",
+        default="app_src.stage_snowflake_cli_scratch",
+    )
+    distribution: Optional[DistributionOptions] = Field(
+        title="Distribution of the application package created by the Snowflake CLI",
+        default="internal",
+    )
+    manifest: Path = Field(
+        title="Path to manifest.yml",
+    )