snowflake-cli-labs 3.0.0rc2__py3-none-any.whl → 3.0.0rc4__py3-none-any.whl

snowflake/cli/_plugins/streamlit/manager.py

@@ -26,15 +26,15 @@ from snowflake.cli._plugins.connection.util import (
 )
 from snowflake.cli._plugins.object.manager import ObjectManager
 from snowflake.cli._plugins.stage.manager import StageManager
+from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
+    StreamlitEntityModel,
+)
 from snowflake.cli.api.commands.experimental_behaviour import (
     experimental_behaviour_enabled,
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.schemas.entities.streamlit_entity_model import (
-    StreamlitEntityModel,
-)
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
@@ -43,6 +43,10 @@ log = logging.getLogger(__name__)
 
 
 class StreamlitManager(SqlExecutionMixin):
+    def execute(self, app_name: FQN):
+        query = f"EXECUTE STREAMLIT {app_name.sql_identifier}()"
+        return self._execute_query(query=query)
+
     def share(self, streamlit_name: FQN, to_role: str) -> SnowflakeCursor:
         return self._execute_query(
             f"grant usage on streamlit {streamlit_name.sql_identifier} to role {to_role}"
@@ -98,12 +102,16 @@ class StreamlitManager(SqlExecutionMixin):
             query.append(f"ROOT_LOCATION = '{from_stage_name}'")
 
         query.append(f"MAIN_FILE = '{streamlit.main_file}'")
-
+        if streamlit.imports:
+            query.append(streamlit.get_imports_sql())
         if streamlit.query_warehouse:
             query.append(f"QUERY_WAREHOUSE = {streamlit.query_warehouse}")
         if streamlit.title:
             query.append(f"TITLE = '{streamlit.title}'")
 
+        if streamlit.comment:
+            query.append(f"COMMENT = '{streamlit.comment}'")
+
         if streamlit.external_access_integrations:
             query.append(streamlit.get_external_access_integrations_sql())
 

snowflake/cli/{api/entities → _plugins/streamlit}/streamlit_entity.py

@@ -1,7 +1,7 @@
-from snowflake.cli.api.entities.common import EntityBase
-from snowflake.cli.api.project.schemas.entities.streamlit_entity_model import (
+from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
+from snowflake.cli.api.entities.common import EntityBase
 
 
 class StreamlitEntity(EntityBase[StreamlitEntityModel]):

snowflake/cli/{api/project/schemas/entities → _plugins/streamlit}/streamlit_entity_model.py

@@ -20,17 +20,19 @@ from pydantic import Field, model_validator
 from snowflake.cli.api.project.schemas.entities.common import (
     EntityModelBase,
     ExternalAccessBaseModel,
+    ImportsBaseModel,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
     DiscriminatorField,
 )
 
 
-class StreamlitEntityModel(EntityModelBase, ExternalAccessBaseModel):
+class StreamlitEntityModel(EntityModelBase, ExternalAccessBaseModel, ImportsBaseModel):
     type: Literal["streamlit"] = DiscriminatorField()  # noqa: A003
     title: Optional[str] = Field(
         title="Human-readable title for the Streamlit dashboard", default=None
     )
+    comment: Optional[str] = Field(title="Comment for the Streamlit app", default=None)
     query_warehouse: str = Field(
         title="Snowflake warehouse to host the app", default=None
     )
@@ -48,23 +50,14 @@ class StreamlitEntityModel(EntityModelBase, ExternalAccessBaseModel):
         default=None,
     )
 
-    @model_validator(mode="after")
-    def main_file_must_be_in_artifacts(self):
-        if not self.artifacts:
-            return self
-
-        if Path(self.main_file) not in self.artifacts:
-            raise ValueError(
-                f"Specified main file {self.main_file} is not included in artifacts."
-            )
-        return self
-
     @model_validator(mode="after")
     def artifacts_must_exists(self):
         if not self.artifacts:
             return self
 
         for artifact in self.artifacts:
+            if "*" in artifact.name:
+                continue
             if not artifact.exists():
                 raise ValueError(
                     f"Specified artifact {artifact} does not exist locally."

snowflake/cli/_plugins/workspace/commands.py

@@ -20,7 +20,7 @@ from textwrap import dedent
 from typing import List, Optional
 
 import typer
-import yaml
+from click import MissingParameter
 from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
@@ -30,50 +30,19 @@ from snowflake.cli._plugins.nativeapp.common_flags import (
 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 SnowTyper
+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.types import MessageResult
-from snowflake.cli.api.project.definition_conversion import (
-    convert_project_definition_to_v2,
-)
-from snowflake.cli.api.project.definition_manager import DefinitionManager
-from snowflake.cli.api.secure_path import SecurePath
+from snowflake.cli.api.output.types import MessageResult, QueryResult
 
-ws = SnowTyper(
+ws = SnowTyperFactory(
     name="ws",
     help="Deploy and interact with snowflake.yml-based entities.",
+    is_hidden=lambda: True,
 )
 log = logging.getLogger(__name__)
 
 
-@ws.command()
-def migrate(
-    accept_templates: bool = typer.Option(
-        False, "-t", "--accept-templates", help="Allows the migration of templates."
-    ),
-    **options,
-):
-    """Migrates the Snowpark, Streamlit, and Native App project definition files from V1 to V2."""
-    manager = DefinitionManager()
-    pd = manager.unrendered_project_definition
-
-    if pd.meets_version_requirement("2"):
-        return MessageResult("Project definition is already at version 2.")
-
-    pd_v2 = convert_project_definition_to_v2(manager.project_root, pd, accept_templates)
-
-    SecurePath("snowflake.yml").rename("snowflake_V1.yml")
-    with open("snowflake.yml", "w") as file:
-        yaml.dump(
-            pd_v2.model_dump(
-                exclude_unset=True, exclude_none=True, mode="json", by_alias=True
-            ),
-            file,
-        )
-    return MessageResult("Project definition migrated to version 2.")
-
-
 @ws.command(requires_connection=True, hidden=True)
 @with_project_definition()
 def bundle(
@@ -211,6 +180,8 @@ def validate(
     entity_id: str = typer.Option(
         help=f"""The ID of the entity you want to validate.""",
     ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
     **options,
 ):
     """Validates the specified entity."""
@@ -223,4 +194,113 @@ def validate(
     ws.perform_action(
         entity_id,
         EntityActions.VALIDATE,
+        interactive=interactive,
+        force=force,
+    )
+
+
+version = SnowTyperFactory(
+    name="version",
+    help="Manages versions for project entities.",
+)
+ws.add_typer(version)
+
+
+@version.command(name="list", requires_connection=True, hidden=True)
+@with_project_definition()
+def version_list(
+    entity_id: str = typer.Option(
+        help="The ID of the entity you want to list versions for.",
+    ),
+    **options,
+):
+    """Lists the versions of the specified entity."""
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    cursor = ws.perform_action(
+        entity_id,
+        EntityActions.VERSION_LIST,
+    )
+    return QueryResult(cursor)
+
+
+@version.command(name="create", requires_connection=True, hidden=True)
+@with_project_definition()
+def version_create(
+    entity_id: str = typer.Option(
+        help="The ID of the entity you want to create a version for.",
+    ),
+    version: Optional[str] = typer.Argument(
+        None,
+        help=f"""Version to define in your application package. If the version already exists, an auto-incremented patch is added to the version instead. Defaults to the version specified in the `manifest.yml` file.""",
+    ),
+    patch: Optional[int] = typer.Option(
+        None,
+        "--patch",
+        help=f"""The patch number you want to create for an existing version.
+        Defaults to undefined if it is not set, which means the Snowflake CLI either uses the patch specified in the `manifest.yml` file or automatically generates a new patch number.""",
+    ),
+    skip_git_check: Optional[bool] = typer.Option(
+        False,
+        "--skip-git-check",
+        help="When enabled, the Snowflake CLI skips checking if your project has any untracked or stages files in git. Default: unset.",
+        is_flag=True,
+    ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
+    **options,
+):
+    """Creates a new version for the specified entity."""
+    if version is None and patch is not None:
+        raise MissingParameter("Cannot provide a patch without version!")
+
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    ws.perform_action(
+        entity_id,
+        EntityActions.VERSION_CREATE,
+        version=version,
+        patch=patch,
+        skip_git_check=skip_git_check,
+        interactive=interactive,
+        force=force,
+    )
+
+
+@version.command(name="drop", requires_connection=True, hidden=True)
+@with_project_definition()
+def version_drop(
+    entity_id: str = typer.Option(
+        help="The ID of the entity you want to create a version for.",
+    ),
+    version: Optional[str] = typer.Argument(
+        None,
+        help=f"""Version to define in your application package. If the version already exists, an auto-incremented patch is added to the version instead. Defaults to the version specified in the `manifest.yml` file.""",
+    ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
+    **options,
+):
+    """
+    Drops a version defined for your entity. Versions can either be passed in as an argument to the command or read from the `manifest.yml` file.
+    Dropping patches is not allowed.
+    """
+
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    ws.perform_action(
+        entity_id,
+        EntityActions.VERSION_CREATE,
+        version=version,
+        interactive=interactive,
+        force=force,
     )

snowflake/cli/_plugins/workspace/plugin_spec.py

@@ -26,5 +26,5 @@ def command_spec():
     return CommandSpec(
         parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
         command_type=CommandType.COMMAND_GROUP,
-        typer_instance=commands.ws,
+        typer_instance=commands.ws.create_instance(),
     )

snowflake/cli/api/cli_global_context.py

@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING, Iterator
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
 from snowflake.cli.api.exceptions import MissingConfiguration
+from snowflake.cli.api.metrics import CLIMetrics
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
 from snowflake.connector import SnowflakeConnection
@@ -46,6 +47,8 @@ class _CliGlobalContextManager:
     experimental: bool = False
     enable_tracebacks: bool = True
 
+    metrics: CLIMetrics = field(default_factory=CLIMetrics)
+
     project_path_arg: str | None = None
     project_is_optional: bool = True
     project_env_overrides_args: dict[str, str] = field(default_factory=dict)
@@ -152,6 +155,10 @@ class _CliGlobalContextAccess:
     def enable_tracebacks(self) -> bool:
         return self._manager.enable_tracebacks
 
+    @property
+    def metrics(self):
+        return self._manager.metrics
+
     @property
     def output_format(self) -> OutputFormat:
         return self._manager.output_format

snowflake/cli/api/commands/decorators.py

@@ -29,10 +29,12 @@ from snowflake.cli.api.commands.flags import (
     DiagAllowlistPathOption,
     DiagLogPathOption,
     EnableDiagOption,
+    HostOption,
     MasterTokenOption,
     MfaPasscodeOption,
     OutputFormatOption,
     PasswordOption,
+    PortOption,
     PrivateKeyPathOption,
     RoleOption,
     SchemaOption,
@@ -210,6 +212,18 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=ConnectionOption,
     ),
+    inspect.Parameter(
+        "host",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=HostOption,
+    ),
+    inspect.Parameter(
+        "port",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[int],
+        default=PortOption,
+    ),
     inspect.Parameter(
         "account",
         inspect.Parameter.KEYWORD_ONLY,

snowflake/cli/api/commands/flags.py

@@ -100,6 +100,24 @@ TemporaryConnectionOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+HostOption = typer.Option(
+    None,
+    "--host",
+    help="Host address for the connection. Overrides the value specified for the connection.",
+    callback=_connection_callback("host"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+PortOption = typer.Option(
+    None,
+    "--port",
+    help="Port for the connection. Overrides the value specified for the connection.",
+    callback=_connection_callback("port"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
 AccountOption = typer.Option(
     None,
     "--account",

snowflake/cli/api/commands/snow_typer.py

@@ -105,7 +105,7 @@ class SnowTyper(typer.Typer):
                     result = command_callable(*args, **kw)
                     self.process_result(result)
                     execution.complete(ExecutionStatus.SUCCESS)
-                except Exception as err:
+                except BaseException as err:
                     execution.complete(ExecutionStatus.FAILURE)
                     exception = self.exception_handler(err, execution)
                     raise exception

snowflake/cli/api/config.py

@@ -130,12 +130,21 @@ def config_init(config_file: Optional[Path]):
     create_initial_loggers()
 
 
-def add_connection(name: str, connection_config: ConnectionConfig):
-    set_config_value(
-        section=CONNECTIONS_SECTION,
-        key=name,
-        value=connection_config.to_dict_of_all_non_empty_values(),
-    )
+def add_connection_to_proper_file(name: str, connection_config: ConnectionConfig):
+    if CONNECTIONS_FILE.exists():
+        existing_connections = _read_connections_toml()
+        existing_connections.update(
+            {name: connection_config.to_dict_of_all_non_empty_values()}
+        )
+        _update_connections_toml(existing_connections)
+        return CONNECTIONS_FILE
+    else:
+        set_config_value(
+            section=CONNECTIONS_SECTION,
+            key=name,
+            value=connection_config.to_dict_of_all_non_empty_values(),
+        )
+        return CONFIG_MANAGER.file_path
 
 
 _DEFAULT_LOGS_CONFIG = {
@@ -359,3 +368,13 @@ def get_feature_flags_section() -> Dict[str, bool | Literal["UNKNOWN"]]:
             return "UNKNOWN"
 
     return {k: _bool_or_unknown(v) for k, v in flags.items()}
+
+
+def _read_connections_toml() -> dict:
+    with open(CONNECTIONS_FILE, "r") as f:
+        return tomlkit.loads(f.read()).unwrap()
+
+
+def _update_connections_toml(connections: dict):
+    with open(CONNECTIONS_FILE, "w") as f:
+        f.write(tomlkit.dumps(connections))

snowflake/cli/api/connections.py

@@ -36,6 +36,8 @@ schema_pattern = re.compile(r".+\..+")
 class ConnectionContext:
     # FIXME: can reduce duplication using config.ConnectionConfig
     connection_name: Optional[str] = None
+    host: Optional[str] = None
+    port: Optional[int] = None
     account: Optional[str] = None
     database: Optional[str] = None
     role: Optional[str] = None
@@ -71,7 +73,7 @@ class ConnectionContext:
         Raises KeyError if a non-property is specified as a key.
         """
         field_map = {field.name: field for field in fields(self)}
-        for (key, value) in updates.items():
+        for key, value in updates.items():
             # ensure key represents a property
             if key not in field_map:
                 raise KeyError(f"{key} is not a field of {self.__class__.__name__}")

snowflake/cli/api/entities/common.py

@@ -11,6 +11,10 @@ class EntityActions(str, Enum):
     DROP = "action_drop"
     VALIDATE = "action_validate"
 
+    VERSION_LIST = "action_version_list"
+    VERSION_CREATE = "action_version_create"
+    VERSION_DROP = "action_version_drop"
+
 
 T = TypeVar("T")
 

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 (
@@ -33,8 +31,8 @@ from snowflake.cli.api.errno import (
     NO_WAREHOUSE_SELECTED_IN_SESSION,
 )
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.metrics import CLICounterField
 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,
 )
@@ -80,17 +78,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]:
@@ -263,6 +250,8 @@ def execute_post_deploy_hooks(
     if not post_deploy_hooks:
         return
 
+    get_cli_context().metrics.set_counter(CLICounterField.POST_DEPLOY_SCRIPTS, 1)
+
     with console.phase(f"Executing {deployed_object_type} post-deploy actions"):
         sql_scripts_paths = []
         for hook in post_deploy_hooks:

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}.")
 

snowflake/cli/api/metrics.py

@@ -0,0 +1,92 @@
+# 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 typing import Dict, Optional
+
+
+class _TypePrefix:
+    FEATURES = "features"
+
+
+class _DomainPrefix:
+    GLOBAL = "global"
+    APP = "app"
+    SQL = "sql"
+
+
+class CLICounterField:
+    """
+    for each counter field we're adopting a convention of
+    <type>.<domain>.<name>
+    for example, if we're tracking a global feature, then the field name would be
+    features.global.feature_name
+
+    The metrics API is implemented to be generic, but we are adopting a convention
+    for feature tracking with the following model for a given command execution:
+    * counter not present -> feature is not available
+    * counter == 0 -> feature is available, but not used
+    * counter == 1 -> feature is used
+    this makes it easy to compute percentages for feature dashboards in Snowsight
+    """
+
+    TEMPLATES_PROCESSOR = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.GLOBAL}.templates_processor"
+    )
+    SQL_TEMPLATES = f"{_TypePrefix.FEATURES}.{_DomainPrefix.SQL}.sql_templates"
+    PDF_TEMPLATES = f"{_TypePrefix.FEATURES}.{_DomainPrefix.GLOBAL}.pdf_templates"
+    SNOWPARK_PROCESSOR = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.snowpark_processor"
+    )
+    POST_DEPLOY_SCRIPTS = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.post_deploy_scripts"
+    )
+    PACKAGE_SCRIPTS = f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.package_scripts"
+
+
+class CLIMetrics:
+    """
+    Class to track various metrics across the execution of a command
+    """
+
+    def __init__(self):
+        self._counters: Dict[str, int] = {}
+
+    def __eq__(self, other):
+        if isinstance(other, CLIMetrics):
+            return self._counters == other._counters
+        return False
+
+    def get_counter(self, name: str) -> Optional[int]:
+        return self._counters.get(name)
+
+    def set_counter(self, name: str, value: int) -> None:
+        self._counters[name] = value
+
+    def set_counter_default(self, name: str, value: int) -> None:
+        """
+        sets the counter if it does not already exist
+        """
+        if name not in self._counters:
+            self.set_counter(name, value)
+
+    def increment_counter(self, name: str, value: int = 1) -> None:
+        if name not in self._counters:
+            self.set_counter(name, value)
+        else:
+            self._counters[name] += value
+
+    @property
+    def counters(self) -> Dict[str, int]:
+        # return a copy of the original dict to avoid mutating the original
+        return self._counters.copy()