snowflake-cli-labs 3.0.0rc5__py3-none-any.whl → 3.0.2__py3-none-any.whl

snowflake/cli/_plugins/stage/md5.py

@@ -1,160 +0,0 @@
-# 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
-
-import hashlib
-import logging
-import math
-import os.path
-import re
-from pathlib import Path
-from typing import List, Tuple
-
-from click.exceptions import ClickException
-from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
-from snowflake.connector.constants import S3_CHUNK_SIZE, S3_MAX_PARTS, S3_MIN_PART_SIZE
-
-ONE_MEGABYTE = 1024**2
-READ_BUFFER_BYTES = 64 * 1024
-MD5SUM_REGEX = r"^[A-Fa-f0-9]{32}$"
-MULTIPART_MD5SUM_REGEX = r"^([A-Fa-f0-9]{32})-(\d+)$"
-
-log = logging.getLogger(__name__)
-
-
-class UnknownMD5FormatError(ClickException):
-    def __init__(self, md5: str):
-        super().__init__(f"Unknown md5 format: {md5}")
-
-
-def is_md5sum(checksum: str) -> bool:
-    """
-    Could the provided hexadecimal checksum represent a valid md5sum?
-    """
-    return re.match(MD5SUM_REGEX, checksum) is not None
-
-
-def parse_multipart_md5sum(checksum: str) -> Tuple[str, int] | None:
-    """
-    Does this represent a multi-part md5sum (i.e. "<md5>-<n>")?
-    If so, returns the tuple (md5, n), otherwise None.
-    """
-    multipart_md5 = re.match(MULTIPART_MD5SUM_REGEX, checksum)
-    if multipart_md5:
-        return (multipart_md5.group(1), int(multipart_md5.group(2)))
-    return None
-
-
-def compute_md5sum(file: Path, chunk_size: int | None = None) -> str:
-    """
-    Returns a hexadecimal checksum for the file located at the given path.
-    If chunk_size is given, computes a multi-part md5sum.
-    """
-    if not file.is_file():
-        raise ValueError(
-            "The provided file does not exist or not a (symlink to a) regular file"
-        )
-
-    # If the stage uses SNOWFLAKE_FULL encryption, this will fail to provide
-    # a matching md5sum, even when the underlying file is the same, as we do
-    # not have access to the encrypted file under checksum.
-
-    file_size = os.path.getsize(file)
-    if file_size == 0:
-        # simple md5 with no content
-        return hashlib.md5().hexdigest()
-
-    with SecurePath(file).open("rb", read_file_limit_mb=UNLIMITED) as f:
-        md5s: List[hashlib._Hash] = []  # noqa: SLF001
-        hasher = hashlib.md5()
-
-        remains = file_size
-        remains_in_chunk: int = min(chunk_size, remains) if chunk_size else remains
-        while remains > 0:
-            sz = min(READ_BUFFER_BYTES, remains_in_chunk)
-            buf = f.read(sz)
-            hasher.update(buf)
-            remains_in_chunk -= sz
-            remains -= sz
-            if remains_in_chunk == 0:
-                if not chunk_size:
-                    # simple md5; only one chunk processed
-                    return hasher.hexdigest()
-                else:
-                    # push the hash of this chunk + reset
-                    md5s.append(hasher)
-                    hasher = hashlib.md5()
-                    remains_in_chunk = min(chunk_size, remains)
-
-        # multi-part hash (e.g. aws)
-        digests = b"".join(m.digest() for m in md5s)
-        digests_md5 = hashlib.md5(digests)
-        return f"{digests_md5.hexdigest()}-{len(md5s)}"
-
-
-def file_matches_md5sum(local_file: Path, remote_md5: str | None) -> bool:
-    """
-    Try a few different md5sums to determine if a local file is identical
-    to a file that has a given remote md5sum.
-
-    Handles the multi-part md5sums generated by e.g. AWS S3, using values
-    from the python connector to make educated guesses on chunk size.
-
-    Assumes that upload time would dominate local hashing time.
-    """
-    if not remote_md5:
-        # no hash available
-        return False
-
-    if is_md5sum(remote_md5):
-        # regular hash
-        return compute_md5sum(local_file) == remote_md5
-
-    if md5_and_chunks := parse_multipart_md5sum(remote_md5):
-        # multi-part hash (e.g. aws)
-        (_, num_chunks) = md5_and_chunks
-        file_size = os.path.getsize(local_file)
-
-        # If this file uses the maximum number of parts supported by the cloud backend,
-        # the chunk size is likely not a clean multiple of a megabyte. Try reverse engineering
-        # from the file size first, then fall back to the usual detection method.
-        # At time of writing this logic would trigger for files >= 80GiB (python connector)
-        if num_chunks == S3_MAX_PARTS:
-            chunk_size = max(math.ceil(file_size / S3_MAX_PARTS), S3_MIN_PART_SIZE)
-            if compute_md5sum(local_file, chunk_size) == remote_md5:
-                return True
-
-        # Estimates the chunk size the multi-part file must have been uploaded with
-        # by trying chunk sizes that give the most evenly-sized chunks.
-        #
-        # First we'll try the chunk size that's a multiple of S3_CHUNK_SIZE (8mb) from
-        # the python connector that results in num_chunks, then we'll do the same with
-        # a smaller granularity (1mb) that is used by default in some AWS multi-part
-        # upload implementations.
-        #
-        # We're working backwards from num_chunks here because it's the only value we know.
-        for chunk_size_alignment in [S3_CHUNK_SIZE, ONE_MEGABYTE]:
-            # +1 because we need at least one chunk when file_size < num_chunks * chunk_size_alignment
-            # -1 because we don't want to add an extra chunk when file_size is an exact multiple of num_chunks * chunk_size_alignment
-            multiplier = 1 + ((file_size - 1) // (num_chunks * chunk_size_alignment))
-            chunk_size = multiplier * chunk_size_alignment
-            if compute_md5sum(local_file, chunk_size) == remote_md5:
-                return True
-
-        # we were unable to figure out the chunk size, or the files are different
-        log.debug("multi-part md5: %s != %s", remote_md5, local_file)
-        return False
-
-    raise UnknownMD5FormatError(remote_md5)

snowflake/cli/_plugins/stage/plugin_spec.py

@@ -1,30 +0,0 @@
-# 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._plugins.stage import commands
-from snowflake.cli.api.plugins.command import (
-    SNOWCLI_ROOT_COMMAND_PATH,
-    CommandSpec,
-    CommandType,
-    plugin_hook_impl,
-)
-
-
-@plugin_hook_impl
-def command_spec():
-    return CommandSpec(
-        parent_command_path=SNOWCLI_ROOT_COMMAND_PATH,
-        command_type=CommandType.COMMAND_GROUP,
-        typer_instance=commands.app.create_instance(),
-    )

snowflake/cli/_plugins/stage/utils.py

@@ -1,54 +0,0 @@
-from typing import Optional
-
-from snowflake.cli._plugins.nativeapp.artifacts import BundleMap
-from snowflake.cli._plugins.stage.diff import (
-    DiffResult,
-    _to_diff_line,
-    _to_src_dest_pair,
-)
-from snowflake.cli.api.console import cli_console as cc
-
-
-def print_diff_to_console(
-    diff: DiffResult,
-    bundle_map: Optional[BundleMap] = None,
-):
-    if not diff.has_changes():
-        cc.message("Your stage is up-to-date with your local deploy root.")
-        return
-
-    blank_line_needed = False
-    if diff.only_local or diff.different:
-        cc.message("Local changes to be deployed:")
-        messages_to_output = []
-        for p in diff.different:
-            src_dest_pair = _to_src_dest_pair(p, bundle_map)
-            messages_to_output.append(
-                (
-                    src_dest_pair,
-                    _to_diff_line("modified", src_dest_pair[0], src_dest_pair[1]),
-                )
-            )
-        for p in diff.only_local:
-            src_dest_pair = _to_src_dest_pair(p, bundle_map)
-            messages_to_output.append(
-                (
-                    src_dest_pair,
-                    _to_diff_line("added", src_dest_pair[0], src_dest_pair[1]),
-                )
-            )
-
-        with cc.indented():
-            for key, message in sorted(messages_to_output, key=lambda pair: pair[0]):
-                cc.message(message)
-
-        blank_line_needed = True
-
-    if diff.only_on_stage:
-        if blank_line_needed:
-            cc.message("")
-        cc.message(f"Deleted paths to be removed from your stage:")
-        with cc.indented():
-            for p in sorted(diff.only_on_stage):
-                diff_line = _to_diff_line("deleted", src=None, dest=str(p))
-                cc.message(diff_line)

snowflake/cli/_plugins/streamlit/__init__.py

@@ -1,13 +0,0 @@
-# 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.

snowflake/cli/_plugins/streamlit/commands.py

@@ -1,195 +0,0 @@
-# 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
-
-import logging
-from pathlib import Path
-from typing import Dict
-
-import click
-import typer
-from click import ClickException, UsageError
-from snowflake.cli._plugins.object.command_aliases import (
-    add_object_command_aliases,
-    scope_option,
-)
-from snowflake.cli._plugins.streamlit.manager import StreamlitManager
-from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
-    StreamlitEntityModel,
-)
-from snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.commands.decorators import (
-    with_experimental_behaviour,
-    with_project_definition,
-)
-from snowflake.cli.api.commands.flags import (
-    ReplaceOption,
-    entity_argument,
-    identifier_argument,
-    like_option,
-)
-from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
-from snowflake.cli.api.constants import ObjectType
-from snowflake.cli.api.exceptions import NoProjectDefinitionError
-from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import (
-    CommandResult,
-    MessageResult,
-    SingleQueryResult,
-)
-from snowflake.cli.api.project.definition_conversion import (
-    convert_project_definition_to_v2,
-)
-
-app = SnowTyperFactory(
-    name="streamlit",
-    help="Manages a Streamlit app in Snowflake.",
-)
-log = logging.getLogger(__name__)
-
-StreamlitNameArgument = identifier_argument(
-    sf_object="Streamlit app", example="my_streamlit"
-)
-OpenOption = typer.Option(
-    False,
-    "--open",
-    help="Whether to open the Streamlit app in a browser.",
-    is_flag=True,
-)
-
-
-add_object_command_aliases(
-    app=app,
-    object_type=ObjectType.STREAMLIT,
-    name_argument=StreamlitNameArgument,
-    like_option=like_option(
-        help_example='`list --like "my%"` lists all streamlit apps that begin with “my”'
-    ),
-    scope_option=scope_option(help_example="`list --in database my_db`"),
-)
-
-
-@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,
-    to_role: str = typer.Argument(
-        ...,
-        help="Role with which to share the Streamlit app.",
-        show_default=False,
-    ),
-    **options,
-) -> CommandResult:
-    """
-    Shares a Streamlit app with another role.
-    """
-    cursor = StreamlitManager().share(streamlit_name=name, to_role=to_role)
-    return SingleQueryResult(cursor)
-
-
-def _default_file_callback(param_name: str):
-    from click.core import ParameterSource  # type: ignore
-
-    def _check_file_exists_if_not_default(ctx: click.Context, value):
-        if (
-            ctx.get_parameter_source(param_name) != ParameterSource.DEFAULT  # type: ignore
-            and value
-            and not Path(value).exists()
-        ):
-            raise ClickException(f"Provided file {value} does not exist")
-        return Path(value)
-
-    return _check_file_exists_if_not_default
-
-
-@app.command("deploy", requires_connection=True)
-@with_project_definition()
-@with_experimental_behaviour()
-def streamlit_deploy(
-    replace: bool = ReplaceOption(
-        help="Replace the Streamlit app if it already exists."
-    ),
-    entity_id: str = entity_argument("streamlit"),
-    open_: bool = OpenOption,
-    **options,
-) -> CommandResult:
-    """
-    Deploys a Streamlit app defined in the project definition file (snowflake.yml). By default, the command uploads
-    environment.yml and any other pages or folders, if present. If you don’t specify a stage name, the `streamlit`
-    stage is used. If the specified stage does not exist, the command creates it. If multiple Streamlits are defined
-    in snowflake.yml and no entity_id is provided then command will raise an error.
-    """
-
-    cli_context = get_cli_context()
-    pd = cli_context.project_definition
-    if not pd.meets_version_requirement("2"):
-        if not pd.streamlit:
-            raise NoProjectDefinitionError(
-                project_type="streamlit", project_root=cli_context.project_root
-            )
-        pd = convert_project_definition_to_v2(cli_context.project_root, pd)
-
-    streamlits: Dict[str, StreamlitEntityModel] = pd.get_entities_by_type(
-        entity_type="streamlit"
-    )
-
-    if not streamlits:
-        raise NoProjectDefinitionError(
-            project_type="streamlit", project_root=cli_context.project_root
-        )
-
-    if entity_id and entity_id not in streamlits:
-        raise UsageError(f"No '{entity_id}' entity in project definition file.")
-
-    if len(streamlits.keys()) == 1:
-        entity_id = list(streamlits.keys())[0]
-
-    if entity_id is None:
-        raise UsageError(
-            "Multiple Streamlit apps found. Please provide entity id for the operation."
-        )
-
-    # Get first streamlit
-    streamlit: StreamlitEntityModel = streamlits[entity_id]
-    url = StreamlitManager().deploy(streamlit=streamlit, replace=replace)
-
-    if open_:
-        typer.launch(url)
-
-    return MessageResult(f"Streamlit successfully deployed and available under {url}")
-
-
-@app.command("get-url", requires_connection=True)
-def get_url(
-    name: FQN = StreamlitNameArgument,
-    open_: bool = OpenOption,
-    **options,
-):
-    """Returns a URL to the specified Streamlit app"""
-    url = StreamlitManager().get_url(streamlit_name=name)
-    if open_:
-        typer.launch(url)
-    return MessageResult(url)

snowflake/cli/_plugins/streamlit/manager.py

@@ -1,220 +0,0 @@
-# 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
-
-import logging
-from pathlib import Path
-from typing import List, Optional
-
-from click import ClickException
-from snowflake.cli._plugins.connection.util import (
-    MissingConnectionAccountError,
-    MissingConnectionRegionError,
-    make_snowsight_url,
-)
-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.sql_execution import SqlExecutionMixin
-from snowflake.connector.cursor import SnowflakeCursor
-from snowflake.connector.errors import ProgrammingError
-
-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}"
-        )
-
-    def _put_streamlit_files(
-        self,
-        root_location: str,
-        artifacts: Optional[List[Path]] = 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)
-
-    def _create_streamlit(
-        self,
-        streamlit: StreamlitEntityModel,
-        replace: Optional[bool] = None,
-        experimental: Optional[bool] = None,
-        from_stage_name: Optional[str] = None,
-    ):
-        streamlit_id = streamlit.fqn.using_connection(self._conn)
-        cli_console.step(f"Creating {streamlit_id} Streamlit")
-        query = []
-        if replace:
-            query.append(f"CREATE OR REPLACE STREAMLIT {streamlit_id.sql_identifier}")
-        elif experimental:
-            # For experimental behaviour, we need to use CREATE STREAMLIT IF NOT EXISTS
-            # for a streamlit app with an embedded stage
-            # because this is analogous to the behavior for non-experimental
-            # deploy which does CREATE STAGE IF NOT EXISTS
-            query.append(
-                f"CREATE STREAMLIT IF NOT EXISTS {streamlit_id.sql_identifier}"
-            )
-        else:
-            query.append(f"CREATE STREAMLIT {streamlit_id.sql_identifier}")
-
-        if from_stage_name:
-            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())
-
-        if streamlit.secrets:
-            query.append(streamlit.get_secrets_sql())
-
-        self._execute_query("\n".join(query))
-
-    def deploy(self, streamlit: StreamlitEntityModel, replace: bool = False):
-        streamlit_id = streamlit.fqn.using_connection(self._conn)
-        if (
-            ObjectManager().object_exists(object_type="streamlit", fqn=streamlit_id)
-            and not replace
-        ):
-            raise ClickException(
-                f"Streamlit {streamlit.fqn} already exist. If you want to replace it use --replace flag."
-            )
-
-        # for backwards compatibility - quoted stage path might be case-sensitive
-        # https://docs.snowflake.com/en/sql-reference/identifiers-syntax#double-quoted-identifiers
-        streamlit_name_for_root_location = streamlit_id.name
-        use_versioned_stage = FeatureFlag.ENABLE_STREAMLIT_VERSIONED_STAGE.is_enabled()
-        if (
-            experimental_behaviour_enabled()
-            or FeatureFlag.ENABLE_STREAMLIT_EMBEDDED_STAGE.is_enabled()
-            or use_versioned_stage
-        ):
-            """
-            1. Create streamlit object
-            2. Upload files to embedded stage
-            """
-            # TODO: Support from_stage
-            # from_stage_stmt = f"FROM_STAGE = '{stage_name}'" if stage_name else ""
-            self._create_streamlit(
-                streamlit=streamlit,
-                replace=replace,
-                experimental=True,
-            )
-            try:
-                if use_versioned_stage:
-                    self._execute_query(
-                        f"ALTER STREAMLIT {streamlit_id.identifier} ADD LIVE VERSION FROM LAST"
-                    )
-                elif not FeatureFlag.ENABLE_STREAMLIT_NO_CHECKOUTS.is_enabled():
-                    self._execute_query(
-                        f"ALTER streamlit {streamlit_id.identifier} CHECKOUT"
-                    )
-            except ProgrammingError as e:
-                # If an error is raised because a CHECKOUT has already occurred or a LIVE VERSION already exists, simply skip it and continue
-                if "Checkout already exists" in str(
-                    e
-                ) or "There is already a live version" in str(e):
-                    log.info("Checkout already exists, continuing")
-                else:
-                    raise
-
-            stage_path = streamlit_id.identifier
-            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"
-            else:
-                root_location = f"{embedded_stage_name}/default_checkout"
-
-            self._put_streamlit_files(
-                root_location,
-                streamlit.artifacts,
-            )
-        else:
-            """
-            1. Create stage
-            2. Upload files to created stage
-            3. Create streamlit from stage
-            """
-            stage_manager = StageManager()
-
-            stage_name = streamlit.stage or "streamlit"
-            stage_name = FQN.from_string(stage_name).using_connection(self._conn)
-
-            cli_console.step(f"Creating {stage_name} stage")
-            stage_manager.create(fqn=stage_name)
-
-            root_location = stage_manager.get_standard_stage_prefix(
-                f"{stage_name}/{streamlit_name_for_root_location}"
-            )
-
-            self._put_streamlit_files(root_location, streamlit.artifacts)
-
-            self._create_streamlit(
-                streamlit=streamlit,
-                replace=replace,
-                from_stage_name=root_location,
-                experimental=False,
-            )
-
-        return self.get_url(streamlit_name=streamlit_id)
-
-    def get_url(self, streamlit_name: FQN) -> str:
-        try:
-            fqn = streamlit_name.using_connection(self._conn)
-            return make_snowsight_url(
-                self._conn,
-                f"/#/streamlit-apps/{fqn.url_identifier}",
-            )
-        except (MissingConnectionRegionError, MissingConnectionAccountError) as e:
-            return "https://app.snowflake.com"