snowflake-cli 3.3.0__py3-none-any.whl → 3.5.0__py3-none-any.whl

snowflake/cli/_plugins/streamlit/manager.py

@@ -15,7 +15,6 @@
 from __future__ import annotations
 
 import logging
-from pathlib import Path
 from typing import List, Optional
 
 from click import ClickException
@@ -29,12 +28,17 @@ from snowflake.cli._plugins.stage.manager import StageManager
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
+from snowflake.cli._plugins.streamlit.streamlit_project_paths import (
+    StreamlitProjectPaths,
+)
+from snowflake.cli.api.artifacts.upload import put_files
 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.common import PathMapping
 from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
@@ -54,26 +58,16 @@ class StreamlitManager(SqlExecutionMixin):
 
     def _put_streamlit_files(
         self,
-        root_location: str,
-        artifacts: Optional[List[Path]] = None,
+        streamlit_project_paths: StreamlitProjectPaths,
+        stage_root: str,
+        artifacts: Optional[List[PathMapping]] = None,
     ):
-        cli_console.step(f"Deploying files to {root_location}")
-        if not artifacts:
-            return
-        stage_manager = StageManager()
-        for file in artifacts:
-            if file.is_dir():
-                if not any(file.iterdir()):
-                    cli_console.warning(f"Skipping empty directory: {file}")
-                    continue
-
-                stage_manager.put(
-                    f"{file.joinpath('*')}", f"{root_location}/{file}", 4, True
-                )
-            elif len(file.parts) > 1:
-                stage_manager.put(file, f"{root_location}/{file.parent}", 4, True)
-            else:
-                stage_manager.put(file, root_location, 4, True)
+        cli_console.step(f"Deploying files to {stage_root}")
+        put_files(
+            project_paths=streamlit_project_paths,
+            stage_root=stage_root,
+            artifacts=artifacts,
+        )
 
     def _create_streamlit(
         self,
@@ -127,7 +121,12 @@ class StreamlitManager(SqlExecutionMixin):
 
         self.execute_query("\n".join(query))
 
-    def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
+    def deploy(
+        self,
+        streamlit: StreamlitEntityModel,
+        streamlit_project_paths: StreamlitProjectPaths,
+        replace: bool = False,
+    ):
         streamlit_id = streamlit.fqn.using_connection(self._conn)
         if (
             ObjectManager().object_exists(object_type="streamlit", fqn=streamlit_id)
@@ -179,12 +178,13 @@ class StreamlitManager(SqlExecutionMixin):
             embedded_stage_name = f"snow://streamlit/{stage_path}"
             if use_versioned_stage:
                 # "LIVE" is the only supported version for now, but this may change later.
-                root_location = f"{embedded_stage_name}/versions/live"
+                stage_root = f"{embedded_stage_name}/versions/live"
             else:
-                root_location = f"{embedded_stage_name}/default_checkout"
+                stage_root = f"{embedded_stage_name}/default_checkout"
 
             self._put_streamlit_files(
-                root_location,
+                streamlit_project_paths,
+                stage_root,
                 streamlit.artifacts,
             )
         else:
@@ -201,21 +201,31 @@ class StreamlitManager(SqlExecutionMixin):
             cli_console.step(f"Creating {stage_name} stage")
             stage_manager.create(fqn=stage_name)
 
-            root_location = stage_manager.get_standard_stage_prefix(
+            stage_root = stage_manager.get_standard_stage_prefix(
                 f"{stage_name}/{streamlit_name_for_root_location}"
             )
 
-            self._put_streamlit_files(root_location, streamlit.artifacts)
+            self._put_streamlit_files(
+                streamlit_project_paths, stage_root, streamlit.artifacts
+            )
 
             self._create_streamlit(
                 streamlit=streamlit,
                 replace=replace,
-                from_stage_name=root_location,
+                from_stage_name=stage_root,
                 experimental=False,
             )
 
+            self.grant_privileges(streamlit)
+
         return self.get_url(streamlit_name=streamlit_id)
 
+    def grant_privileges(self, entity_model: StreamlitEntityModel):
+        if not entity_model.grants:
+            return
+        for grant in entity_model.grants:
+            self.execute_query(grant.get_grant_sql(entity_model))
+
     def get_url(self, streamlit_name: FQN) -> str:
         try:
             fqn = streamlit_name.using_connection(self._conn)

snowflake/cli/_plugins/streamlit/streamlit_entity.py

@@ -1,16 +1,17 @@
-import functools
 from pathlib import Path
 from typing import Optional
 
 from click import ClickException
 from snowflake.cli._plugins.connection.util import make_snowsight_url
+from snowflake.cli._plugins.nativeapp.artifacts import build_bundle
 from snowflake.cli._plugins.nativeapp.feature_flags import FeatureFlag
 from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
     StreamlitEntityModel,
 )
 from snowflake.cli._plugins.workspace.context import ActionContext
-from snowflake.cli.api.entities.common import EntityBase, get_sql_executor
-from snowflake.cli.api.secure_path import SecurePath
+from snowflake.cli.api.entities.common import EntityBase
+from snowflake.cli.api.project.project_paths import bundle_root
+from snowflake.cli.api.project.schemas.entities.common import PathMapping
 from snowflake.connector.cursor import SnowflakeCursor
 
 
@@ -32,18 +33,6 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
     def artifacts(self):
         return self._entity_model.artifacts
 
-    @functools.cached_property
-    def _sql_executor(self):
-        return get_sql_executor()
-
-    @functools.cached_property
-    def _conn(self):
-        return self._sql_executor._conn  # noqa
-
-    @property
-    def model(self):
-        return self._entity_model  # noqa
-
     def action_bundle(self, action_ctx: ActionContext, *args, **kwargs):
         return self.bundle()
 
@@ -51,15 +40,15 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         # After adding bundle map- we should use it's mapping here
         # To copy artifacts to destination on stage.
 
-        return self._sql_executor.execute_query(self.get_deploy_sql())
+        return self.deploy()
 
     def action_drop(self, action_ctx: ActionContext, *args, **kwargs):
-        return self._sql_executor.execute_query(self.get_drop_sql())
+        return self._execute_query(self.get_drop_sql())
 
     def action_execute(
         self, action_ctx: ActionContext, *args, **kwargs
     ) -> SnowflakeCursor:
-        return self._sql_executor.execute_query(self.get_execute_sql())
+        return self._execute_query(self.get_execute_sql())
 
     def action_get_url(
         self, action_ctx: ActionContext, *args, **kwargs
@@ -70,34 +59,24 @@ class StreamlitEntity(EntityBase[StreamlitEntityModel]):
         )
 
     def bundle(self, output_dir: Optional[Path] = None):
+        build_bundle(
+            self.root,
+            output_dir or bundle_root(self.root, "streamlit"),
+            [
+                PathMapping(
+                    src=artifact.src, dest=artifact.dest, processors=artifact.processors
+                )
+                for artifact in self._entity_model.artifacts
+            ],
+        )
 
-        if not output_dir:
-            output_dir = self.root / "output" / self._entity_model.stage
-
-        artifacts = self._entity_model.artifacts
-
-        output_dir.mkdir(parents=True, exist_ok=True)  # type: ignore
-
-        output_files = []
-
-        # This is far from , but will be replaced by bundlemap mappings.
-        for file in artifacts:
-            output_file = output_dir / file.name
-
-            if file.is_file():
-                SecurePath(file).copy(output_file)
-            elif file.is_dir():
-                output_file.mkdir(parents=True, exist_ok=True)
-                SecurePath(file).copy(output_file, dirs_exist_ok=True)
-
-                output_files.append(output_file)
-
-        return output_files
+    def deploy(self, *args, **kwargs):
+        return self._execute_query(self.get_deploy_sql())
 
     def action_share(
         self, action_ctx: ActionContext, to_role: str, *args, **kwargs
     ) -> SnowflakeCursor:
-        return self._sql_executor.execute_query(self.get_share_sql(to_role))
+        return self._execute_query(self.get_share_sql(to_role))
 
     def get_deploy_sql(
         self,

snowflake/cli/_plugins/streamlit/streamlit_entity_model.py

@@ -13,13 +13,14 @@
 # limitations under the License.
 from __future__ import annotations
 
-from pathlib import Path
-from typing import List, Literal, Optional
+from typing import Literal, Optional
 
-from pydantic import Field, model_validator
+from pydantic import Field
 from snowflake.cli.api.project.schemas.entities.common import (
-    EntityModelBase,
+    Artifacts,
+    EntityModelBaseWithArtifacts,
     ExternalAccessBaseModel,
+    GrantBaseModel,
     ImportsBaseModel,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
@@ -27,7 +28,12 @@ from snowflake.cli.api.project.schemas.updatable_model import (
 )
 
 
-class StreamlitEntityModel(EntityModelBase, ExternalAccessBaseModel, ImportsBaseModel):
+class StreamlitEntityModel(
+    EntityModelBaseWithArtifacts,
+    ExternalAccessBaseModel,
+    ImportsBaseModel,
+    GrantBaseModel,
+):
     type: Literal["streamlit"] = DiscriminatorField()  # noqa: A003
     title: Optional[str] = Field(
         title="Human-readable title for the Streamlit dashboard", default=None
@@ -43,24 +49,8 @@ class StreamlitEntityModel(EntityModelBase, ExternalAccessBaseModel, ImportsBase
     stage: Optional[str] = Field(
         title="Stage in which the app’s artifacts will be stored", default="streamlit"
     )
-    # Possibly can be PathMapping
-    artifacts: Optional[List[Path]] = Field(
-        title="List of files which should be deployed. Each file needs to exist locally. "
-        "Main file needs to be included in the artifacts.",
+    # Artifacts were optional, so to avoid BCR, we need to make them optional here as well
+    artifacts: Optional[Artifacts] = Field(
+        title="List of paths or file source/destination pairs to add to the deploy root",
         default=None,
     )
-
-    @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."
-                )
-
-        return self

snowflake/cli/_plugins/streamlit/streamlit_project_paths.py

@@ -0,0 +1,30 @@
+# 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 dataclasses import dataclass
+from pathlib import Path
+
+from snowflake.cli.api.project.project_paths import ProjectPaths, bundle_root
+
+
+@dataclass
+class StreamlitProjectPaths(ProjectPaths):
+    """
+    This class allows you to manage files paths related to given project.
+    """
+
+    @property
+    def bundle_root(self) -> Path:
+        return bundle_root(self.project_root, "streamlit")

snowflake/cli/_plugins/workspace/commands.py

@@ -22,17 +22,17 @@ from typing import List, Optional
 
 import typer
 import yaml
-from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.nativeapp.common_flags import (
     ForceOption,
     InteractiveOption,
     ValidateOption,
 )
 from snowflake.cli._plugins.workspace.manager import WorkspaceManager
+from snowflake.cli.api.artifacts.bundle_map import BundleMap
 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.entities.utils import EntityActions
 from snowflake.cli.api.exceptions import IncompatibleParametersError
 from snowflake.cli.api.output.types import CollectionResult, MessageResult
 
@@ -106,7 +106,7 @@ def deploy(
         show_default=False,
         help=dedent(
             f"""
-            Paths, relative to the the project root, of files or directories you want to upload to a stage. If a file is
+            Paths, relative to the project root, of files or directories you want to upload to a stage. If a file is
             specified, it must match one of the artifacts src pattern entries in snowflake.yml. If a directory is
             specified, it will be searched for subfolders or files to deploy based on artifacts src pattern entries. If
             unspecified, the command syncs all local changes to the stage."""

snowflake/cli/_plugins/workspace/manager.py

@@ -5,7 +5,7 @@ from typing import Dict
 from snowflake.cli._plugins.workspace.context import ActionContext, WorkspaceContext
 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.entities.common import EntityActions, get_sql_executor
+from snowflake.cli.api.entities.utils import EntityActions, get_sql_executor
 from snowflake.cli.api.exceptions import InvalidProjectDefinitionVersionError
 from snowflake.cli.api.project.definition import default_role
 from snowflake.cli.api.project.schemas.entities.entities import (