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

snowflake/cli/_plugins/nativeapp/manager.py

@@ -14,28 +14,22 @@
 
 from __future__ import annotations
 
-import time
 from abc import ABC, abstractmethod
 from datetime import datetime
 from functools import cached_property
 from pathlib import Path
-from textwrap import dedent
 from typing import Generator, List, Optional
 
-from snowflake.cli._plugins.connection.util import make_snowsight_url
-from snowflake.cli._plugins.nativeapp.application_entity import (
+from snowflake.cli._plugins.nativeapp.artifacts import (
+    BundleMap,
+)
+from snowflake.cli._plugins.nativeapp.entities.application import (
     ApplicationEntity,
     ApplicationOwnedObject,
 )
-from snowflake.cli._plugins.nativeapp.application_package_entity import (
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
 )
-from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
-)
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    NoEventTableForAccount,
-)
 from snowflake.cli._plugins.nativeapp.policy import AllowAlwaysPolicy, PolicyBase
 from snowflake.cli._plugins.nativeapp.project_model import (
     NativeAppProjectModel,
@@ -46,18 +40,11 @@ from snowflake.cli._plugins.stage.diff import (
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.entities.utils import (
     execute_post_deploy_hooks,
-    generic_sql_error_handler,
     sync_deploy_root_with_stage,
 )
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
 from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.util import (
-    identifier_for_url,
-    unquote_identifier,
-)
-from snowflake.cli.api.sql_execution import SqlExecutionMixin
-from snowflake.connector import DictCursor, ProgrammingError
 
 
 class NativeAppCommandProcessor(ABC):
@@ -66,7 +53,7 @@ class NativeAppCommandProcessor(ABC):
         pass
 
 
-class NativeAppManager(SqlExecutionMixin):
+class NativeAppManager:
     """
     Base class with frequently used functionality already implemented and ready to be used by related subclasses.
     """
@@ -135,9 +122,6 @@ class NativeAppManager(SqlExecutionMixin):
     def application_warehouse(self) -> Optional[str]:
         return self.na_project.application_warehouse
 
-    def use_application_warehouse(self):
-        return ApplicationEntity.use_application_warehouse(self.application_warehouse)
-
     @property
     def project_identifier(self) -> str:
         return self.na_project.project_identifier
@@ -182,9 +166,7 @@ class NativeAppManager(SqlExecutionMixin):
 
     @cached_property
     def account_event_table(self) -> str:
-        query = "show parameters like 'event_table' in account"
-        results = self._execute_query(query, cursor_class=DictCursor)
-        return next((r["value"] for r in results if r["key"] == "EVENT_TABLE"), "")
+        return ApplicationEntity.get_account_event_table()
 
     def verify_project_distribution(
         self, expected_distribution: Optional[str] = None
@@ -262,9 +244,9 @@ class NativeAppManager(SqlExecutionMixin):
 
     def get_snowsight_url(self) -> str:
         """Returns the URL that can be used to visit this app via Snowsight."""
-        name = identifier_for_url(self.app_name)
-        with self.use_application_warehouse():
-            return make_snowsight_url(self._conn, f"/#/apps/application/{name}")
+        return ApplicationEntity.get_snowsight_url(
+            self.app_name, self.application_warehouse
+        )
 
     def create_app_package(self) -> None:
         return ApplicationPackageEntity.create_app_package(
@@ -336,41 +318,53 @@ class NativeAppManager(SqlExecutionMixin):
             policy=policy,
         )
 
-    def deploy_to_scratch_stage_fn(self):
-        bundle_map = self.build_bundle()
-        self.deploy(
-            bundle_map=bundle_map,
-            prune=True,
-            recursive=True,
-            stage_fqn=self.scratch_stage_fqn,
-            validate=False,
-            print_diff=False,
-            policy=AllowAlwaysPolicy(),
-        )
-
     def validate(self, use_scratch_stage: bool = False):
         return ApplicationPackageEntity.validate_setup_script(
             console=cc,
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            artifacts=self.artifacts,
             package_name=self.package_name,
             package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            prune=True,
+            recursive=True,
+            paths=[],
             stage_fqn=self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+            policy=AllowAlwaysPolicy(),
             use_scratch_stage=use_scratch_stage,
             scratch_stage_fqn=self.scratch_stage_fqn,
-            deploy_to_scratch_stage_fn=self.deploy_to_scratch_stage_fn,
         )
 
-    def get_validation_result(self, use_scratch_stage: bool):
+    def get_validation_result(self, use_scratch_stage: bool = False):
         return ApplicationPackageEntity.get_validation_result(
             console=cc,
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            artifacts=self.artifacts,
             package_name=self.package_name,
             package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            prune=True,
+            recursive=True,
+            paths=[],
             stage_fqn=self.stage_fqn,
+            package_warehouse=self.package_warehouse,
+            post_deploy_hooks=self.package_post_deploy_hooks,
+            package_scripts=self.package_scripts,
+            policy=AllowAlwaysPolicy(),
             use_scratch_stage=use_scratch_stage,
             scratch_stage_fqn=self.scratch_stage_fqn,
-            deploy_to_scratch_stage_fn=self.deploy_to_scratch_stage_fn,
         )
 
-    def get_events(  # type: ignore [return]
+    def get_events(  # type: ignore
         self,
         since: str | datetime | None = None,
         until: str | datetime | None = None,
@@ -382,87 +376,19 @@ class NativeAppManager(SqlExecutionMixin):
         first: int = -1,
         last: int = -1,
     ) -> list[dict]:
-        record_types = record_types or []
-        scopes = scopes or []
-
-        if first >= 0 and last >= 0:
-            raise ValueError("first and last cannot be used together")
-
-        if not self.account_event_table:
-            raise NoEventTableForAccount()
-
-        # resource_attributes uses the unquoted/uppercase app and package name
-        app_name = unquote_identifier(self.app_name)
-        package_name = unquote_identifier(self.package_name)
-        org_name = unquote_identifier(consumer_org)
-        account_name = unquote_identifier(consumer_account)
-
-        # Filter on record attributes
-        if consumer_org and consumer_account:
-            # Look for events shared from a consumer account
-            app_clause = (
-                f"resource_attributes:\"snow.application.package.name\" = '{package_name}' "
-                f"and resource_attributes:\"snow.application.consumer.organization\" = '{org_name}' "
-                f"and resource_attributes:\"snow.application.consumer.name\" = '{account_name}'"
-            )
-            if consumer_app_hash:
-                # If the user has specified a hash of a specific app installation
-                # in the consumer account, filter events to that installation only
-                app_clause += f" and resource_attributes:\"snow.database.hash\" = '{consumer_app_hash.lower()}'"
-        else:
-            # Otherwise look for events from an app installed in the same account as the package
-            app_clause = f"resource_attributes:\"snow.database.name\" = '{app_name}'"
-
-        # Filter on event time
-        if isinstance(since, datetime):
-            since_clause = f"and timestamp >= '{since}'"
-        elif isinstance(since, str) and since:
-            since_clause = f"and timestamp >= sysdate() - interval '{since}'"
-        else:
-            since_clause = ""
-        if isinstance(until, datetime):
-            until_clause = f"and timestamp <= '{until}'"
-        elif isinstance(until, str) and until:
-            until_clause = f"and timestamp <= sysdate() - interval '{until}'"
-        else:
-            until_clause = ""
-
-        # Filter on event type (log, span, span_event)
-        type_in_values = ",".join(f"'{v}'" for v in record_types)
-        types_clause = (
-            f"and record_type in ({type_in_values})" if type_in_values else ""
-        )
-
-        # Filter on event scope (e.g. the logger name)
-        scope_in_values = ",".join(f"'{v}'" for v in scopes)
-        scopes_clause = (
-            f"and scope:name in ({scope_in_values})" if scope_in_values else ""
-        )
-
-        # Limit event count
-        first_clause = f"limit {first}" if first >= 0 else ""
-        last_clause = f"limit {last}" if last >= 0 else ""
-
-        query = dedent(
-            f"""\
-            select * from (
-                select timestamp, value::varchar value
-                from {self.account_event_table}
-                where ({app_clause})
-                {since_clause}
-                {until_clause}
-                {types_clause}
-                {scopes_clause}
-                order by timestamp desc
-                {last_clause}
-            ) order by timestamp asc
-            {first_clause}
-            """
+        return ApplicationEntity.get_events(
+            app_name=self.app_name,
+            package_name=self.package_name,
+            since=since,
+            until=until,
+            record_types=record_types,
+            scopes=scopes,
+            consumer_org=consumer_org,
+            consumer_account=consumer_account,
+            consumer_app_hash=consumer_app_hash,
+            first=first,
+            last=last,
         )
-        try:
-            return self._execute_query(query, cursor_class=DictCursor).fetchall()
-        except ProgrammingError as err:
-            generic_sql_error_handler(err)
 
     def stream_events(
         self,
@@ -475,62 +401,15 @@ class NativeAppManager(SqlExecutionMixin):
         consumer_app_hash: str = "",
         last: int = -1,
     ) -> Generator[dict, None, None]:
-        try:
-            events = self.get_events(
-                since=since,
-                record_types=record_types,
-                scopes=scopes,
-                consumer_org=consumer_org,
-                consumer_account=consumer_account,
-                consumer_app_hash=consumer_app_hash,
-                last=last,
-            )
-            yield from events  # Yield the initial batch of events
-            last_event_time = events[-1]["TIMESTAMP"] if events else None
-
-            while True:  # Then infinite poll for new events
-                time.sleep(interval_seconds)
-                previous_events = events
-                events = self.get_events(
-                    since=last_event_time,
-                    record_types=record_types,
-                    scopes=scopes,
-                    consumer_org=consumer_org,
-                    consumer_account=consumer_account,
-                    consumer_app_hash=consumer_app_hash,
-                )
-                if not events:
-                    continue
-
-                yield from _new_events_only(previous_events, events)
-                last_event_time = events[-1]["TIMESTAMP"]
-        except KeyboardInterrupt:
-            return
-
-
-def _new_events_only(previous_events: list[dict], new_events: list[dict]) -> list[dict]:
-    # The timestamp that overlaps between both sets of events
-    overlap_time = new_events[0]["TIMESTAMP"]
-
-    # Remove all the events from the new result set
-    # if they were already printed. We iterate and remove
-    # instead of filtering in order to handle duplicates
-    # (i.e. if an event is present 3 times in new_events
-    # but only once in previous_events, it should still
-    # appear twice in new_events at the end
-    new_events = new_events.copy()
-    for event in reversed(previous_events):
-        if event["TIMESTAMP"] < overlap_time:
-            break
-        # No need to handle ValueError here since we know
-        # that events that pass the above if check will
-        # either be in both lists or in new_events only
-        new_events.remove(event)
-    return new_events
-
-
-def _validation_item_to_str(item: dict[str, str | int]):
-    s = item["message"]
-    if item["errorCode"]:
-        s = f"{s} (error code {item['errorCode']})"
-    return s
+        return ApplicationEntity.stream_events(
+            app_name=self.app_name,
+            package_name=self.package_name,
+            interval_seconds=interval_seconds,
+            since=since,
+            record_types=record_types,
+            scopes=scopes,
+            consumer_org=consumer_org,
+            consumer_account=consumer_account,
+            consumer_app_hash=consumer_app_hash,
+            last=last,
+        )

snowflake/cli/_plugins/nativeapp/run_processor.py

@@ -18,13 +18,11 @@ from pathlib import Path
 from typing import Optional
 
 import typer
-from snowflake.cli._plugins.nativeapp.application_entity import (
-    ApplicationEntity,
-)
-from snowflake.cli._plugins.nativeapp.application_package_entity import (
+from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntity
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
 )
-from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
@@ -34,6 +32,7 @@ from snowflake.cli._plugins.nativeapp.same_account_install_method import (
     SameAccountInstallMethod,
 )
 from snowflake.cli.api.console import cli_console as cc
+from snowflake.cli.api.entities.common import get_sql_executor
 from snowflake.cli.api.entities.utils import (
     generic_sql_error_handler,
 )
@@ -100,7 +99,8 @@ class NativeAppRunProcessor(NativeAppManager, NativeAppCommandProcessor):
             cascade_msg = " (cascade)" if cascade else ""
             cc.step(f"Dropping application object {self.app_name}{cascade_msg}.")
             cascade_sql = " cascade" if cascade else ""
-            self._execute_query(f"drop application {self.app_name}{cascade_sql}")
+            sql_executor = get_sql_executor()
+            sql_executor.execute_query(f"drop application {self.app_name}{cascade_sql}")
         except ProgrammingError as err:
             if err.errno == APPLICATION_OWNS_EXTERNAL_OBJECTS and not cascade:
                 # We need to cascade the deletion, let's try again (only if we didn't try with cascade already)

snowflake/cli/_plugins/nativeapp/teardown_processor.py

@@ -17,10 +17,8 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, Optional
 
-from snowflake.cli._plugins.nativeapp.application_entity import (
-    ApplicationEntity,
-)
-from snowflake.cli._plugins.nativeapp.application_package_entity import (
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntity
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
 )
 from snowflake.cli._plugins.nativeapp.manager import (

snowflake/cli/_plugins/nativeapp/v2_conversions/v2_to_v1_decorator.py

@@ -20,10 +20,8 @@ from typing import Any, Dict, Optional, Type, TypeVar, Union
 
 import typer
 from click import ClickException
-from snowflake.cli._plugins.nativeapp.application_entity_model import (
-    ApplicationEntityModel,
-)
-from snowflake.cli._plugins.nativeapp.application_package_entity_model import (
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntityModel,
 )
 from snowflake.cli.api.cli_global_context import (

snowflake/cli/_plugins/nativeapp/version/commands.py

@@ -20,11 +20,6 @@ from typing import Optional
 import typer
 from click import MissingParameter
 from snowflake.cli._plugins.nativeapp.common_flags import ForceOption, InteractiveOption
-from snowflake.cli._plugins.nativeapp.policy import (
-    AllowAlwaysPolicy,
-    AskAlwaysPolicy,
-    DenyAlwaysPolicy,
-)
 from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
 from snowflake.cli._plugins.nativeapp.v2_conversions.v2_to_v1_decorator import (
     nativeapp_definition_v2_to_v1,
@@ -137,19 +132,10 @@ def drop(
 
     assert_project_type("native_app")
 
-    is_interactive = False
-    if force:
-        policy = AllowAlwaysPolicy()
-    elif interactive:
-        is_interactive = True
-        policy = AskAlwaysPolicy()
-    else:
-        policy = DenyAlwaysPolicy()
-
     cli_context = get_cli_context()
     processor = NativeAppVersionDropProcessor(
         project_definition=cli_context.project_definition.native_app,
         project_root=cli_context.project_root,
     )
-    processor.process(version, policy, is_interactive)
+    processor.process(version, force, interactive)
     return MessageResult(f"Version drop is now complete.")

snowflake/cli/_plugins/nativeapp/version/version_processor.py

@@ -15,30 +15,18 @@
 from __future__ import annotations
 
 from pathlib import Path
-from textwrap import dedent
 from typing import Dict, Optional
 
-import typer
-from click import ClickException
-from snowflake.cli._plugins.nativeapp.application_package_entity import (
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
 )
-from snowflake.cli._plugins.nativeapp.artifacts import (
-    find_version_info_in_manifest_file,
-)
-from snowflake.cli._plugins.nativeapp.exceptions import (
-    ApplicationPackageDoesNotExistError,
-)
 from snowflake.cli._plugins.nativeapp.manager import (
     NativeAppCommandProcessor,
     NativeAppManager,
 )
-from snowflake.cli._plugins.nativeapp.policy import PolicyBase
 from snowflake.cli._plugins.nativeapp.run_processor import NativeAppRunProcessor
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.project.schemas.v1.native_app.native_app import NativeApp
-from snowflake.cli.api.project.util import to_identifier
-from snowflake.connector import ProgrammingError
 
 
 class NativeAppVersionCreateProcessor(NativeAppRunProcessor):
@@ -89,76 +77,22 @@ class NativeAppVersionDropProcessor(NativeAppManager, NativeAppCommandProcessor)
     def process(
         self,
         version: Optional[str],
-        policy: PolicyBase,
-        is_interactive: bool,
+        force: bool,
+        interactive: bool,
         *args,
         **kwargs,
     ):
-        """
-        Drops a version defined in an application package. If --force is provided, then no user prompts will be executed.
-        """
-
-        # 1. Check for existing an existing application package
-        show_obj_row = self.get_existing_app_pkg_info()
-        if not show_obj_row:
-            raise ApplicationPackageDoesNotExistError(self.package_name)
-
-        # 2. Check distribution of the existing application package
-        actual_distribution = self.get_app_pkg_distribution_in_snowflake
-        if not self.verify_project_distribution(actual_distribution):
-            cc.warning(
-                f"Continuing to execute `snow app version drop` on application package {self.package_name} with distribution '{actual_distribution}'."
-            )
-
-        # 3. If the user did not pass in a version string, determine from manifest.yml
-        if not version:
-            cc.message(
-                dedent(
-                    f"""\
-                        Version was not provided through the Snowflake CLI. Checking version in the manifest.yml instead.
-                        This step will bundle your app artifacts to determine the location of the manifest.yml file.
-                    """
-                )
-            )
-            self.build_bundle()
-            version, _ = find_version_info_in_manifest_file(self.deploy_root)
-            if not version:
-                raise ClickException(
-                    "Manifest.yml file does not contain a value for the version field."
-                )
-
-        # Make the version a valid identifier, adding quotes if necessary
-        version = to_identifier(version)
-
-        cc.step(
-            dedent(
-                f"""\
-                    About to drop version {version} in application package {self.package_name}.
-                """
-            )
-        )
-
-        # If user did not provide --force, ask for confirmation
-        user_prompt = (
-            f"Are you sure you want to drop version {version} in application package {self.package_name}? Once dropped, this operation cannot be undone.",
-        )
-        if not policy.should_proceed(user_prompt):
-            if is_interactive:
-                cc.message("Not dropping version.")
-                raise typer.Exit(0)
-            else:
-                cc.message("Cannot drop version non-interactively without --force.")
-                raise typer.Exit(1)
-
-        # Drop the version
-        with self.use_role(self.package_role):
-            try:
-                self._execute_query(
-                    f"alter application package {self.package_name} drop version {version}"
-                )
-            except ProgrammingError as err:
-                raise err  # e.g. version is referenced in a release directive(s)
-
-        cc.message(
-            f"Version {version} in application package {self.package_name} dropped successfully."
+        return ApplicationPackageEntity.version_drop(
+            console=cc,
+            project_root=self.project_root,
+            deploy_root=self.deploy_root,
+            bundle_root=self.bundle_root,
+            generated_root=self.generated_root,
+            artifacts=self.artifacts,
+            package_name=self.package_name,
+            package_role=self.package_role,
+            package_distribution=self.package_distribution,
+            version=version,
+            force=force,
+            interactive=interactive,
         )

snowflake/cli/_plugins/object/manager.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-from textwrap import dedent
 from typing import Any, Dict, Optional, Tuple, Union
 
 from click import ClickException
@@ -28,6 +27,7 @@ from snowflake.cli.api.sql_execution import SqlExecutionMixin
 from snowflake.connector import ProgrammingError
 from snowflake.connector.cursor import SnowflakeCursor
 from snowflake.connector.errors import BadRequest
+from snowflake.connector.vendored.requests.exceptions import HTTPError
 
 
 def _get_object_names(object_type: str) -> ObjectNames:
@@ -77,21 +77,42 @@ class ObjectManager(SqlExecutionMixin):
     def create(self, object_type: str, object_data: Dict[str, Any]) -> str:
         rest = RestApi(self._conn)
         url = rest.determine_url_for_create_query(object_type=object_type)
-
         try:
             response = rest.send_rest_request(url=url, method="post", data=object_data)
-            # workaround as SnowflakeRestful class ignores some errors, dropping their info and returns {} instead.
-            if not response:
+        except Exception as err:
+            _handle_create_error_codes(err)
+        return response["status"]
+
+
+def _handle_create_error_codes(err: Exception) -> None:
+    # according to https://docs.snowflake.com/developer-guide/snowflake-rest-api/reference/
+    if isinstance(err, BadRequest):
+        raise ClickException(
+            "400 bad request: Incorrect object definition (arguments misspelled or malformatted)."
+        )
+    if isinstance(err, HTTPError):
+        match err_code := err.response.status_code:
+            case 401:
                 raise ClickException(
-                    dedent(
-                        """                An unexpected error occurred while creating the object. Try again with --debug for more info.
-                Most probable reasons:
-                  * object you are trying to create already exists
-                  * role you are using do not have permissions to create this object"""
-                    )
+                    "401 unauthorized: role you are using does not have permissions to create this object."
                 )
-            return response["status"]
-        except BadRequest:
-            raise ClickException(
-                "Incorrect object definition (arguments misspelled or malformatted)."
-            )
+            # error 403 should be handled by connector
+            # error 404 is handled by determine-url logic
+            # error 405 should not happen under assumption that "all listable objects can be created"
+            case 408:
+                raise ClickException(
+                    "408 timeout: the request timed out and was not completed by the server."
+                )
+            case 409:
+                raise ClickException(
+                    "409 conflict: object you're trying to create already exists."
+                )
+            # error 410 is a network maintenance debugging - should not happen to the user
+            case 429:
+                raise ClickException(
+                    "429 too many requests. The number of requests hit the rate limit."
+                )
+            case 500 | 503 | 504:
+                raise ClickException(f"{err_code} internal server error.")
+            case _:
+                raise err

snowflake/cli/_plugins/streamlit/commands.py

@@ -81,6 +81,18 @@ add_object_command_aliases(
 )
 
 
+@app.command(requires_connection=True)
+def execute(
+    name: FQN = StreamlitNameArgument,
+    **options,
+):
+    """
+    Executes a streamlit in a headless mode.
+    """
+    _ = StreamlitManager().execute(app_name=name)
+    return MessageResult(f"Streamlit {name} executed.")
+
+
 @app.command("share", requires_connection=True)
 def streamlit_share(
     name: FQN = StreamlitNameArgument,

snowflake/cli/_plugins/streamlit/manager.py

@@ -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}"