snowflake-cli-labs 3.0.0rc4__py3-none-any.whl → 3.0.1__py3-none-any.whl

snowflake/cli/_plugins/streamlit/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.streamlit 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/streamlit/streamlit_entity.py

@@ -1,12 +0,0 @@
-from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
-    StreamlitEntityModel,
-)
-from snowflake.cli.api.entities.common import EntityBase
-
-
-class StreamlitEntity(EntityBase[StreamlitEntityModel]):
-    """
-    A Streamlit app.
-    """
-
-    pass

snowflake/cli/_plugins/streamlit/streamlit_entity_model.py

@@ -1,66 +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
-
-from pathlib import Path
-from typing import List, Literal, Optional
-
-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, 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
-    )
-    main_file: Optional[str] = Field(
-        title="Entrypoint file of the Streamlit app", default="streamlit_app.py"
-    )
-    pages_dir: Optional[str] = Field(title="Streamlit pages", default=None)
-    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.",
-        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/workspace/__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/workspace/action_context.py

@@ -1,18 +0,0 @@
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Callable, Optional
-
-from snowflake.cli.api.console.abc import AbstractConsole
-
-
-@dataclass
-class ActionContext:
-    """
-    An object that is passed to each action when called by WorkspaceManager
-    """
-
-    console: AbstractConsole
-    project_root: Path
-    default_role: str
-    default_warehouse: Optional[str]
-    get_entity: Callable

snowflake/cli/_plugins/workspace/commands.py

@@ -1,306 +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 textwrap import dedent
-from typing import List, Optional
-
-import typer
-from click import MissingParameter
-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.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.exceptions import IncompatibleParametersError
-from snowflake.cli.api.output.types import MessageResult, QueryResult
-
-ws = SnowTyperFactory(
-    name="ws",
-    help="Deploy and interact with snowflake.yml-based entities.",
-    is_hidden=lambda: True,
-)
-log = logging.getLogger(__name__)
-
-
-@ws.command(requires_connection=True, hidden=True)
-@with_project_definition()
-def bundle(
-    entity_id: str = typer.Option(
-        help=f"""The ID of the entity you want to bundle.""",
-    ),
-    **options,
-):
-    """
-    Prepares a local folder with the configured artifacts of the specified entity.
-    """
-
-    cli_context = get_cli_context()
-    ws = WorkspaceManager(
-        project_definition=cli_context.project_definition,
-        project_root=cli_context.project_root,
-    )
-
-    bundle_map: BundleMap = ws.perform_action(entity_id, EntityActions.BUNDLE)
-    return MessageResult(f"Bundle generated at {bundle_map.deploy_root()}")
-
-
-@ws.command(requires_connection=True, hidden=True)
-@with_project_definition()
-def deploy(
-    entity_id: str = typer.Option(
-        help=f"""The ID of the entity you want to deploy.""",
-    ),
-    # TODO The following options should be generated automatically, depending on the specified entity type
-    prune: Optional[bool] = typer.Option(
-        default=None,
-        help=f"""Whether to delete specified files from the stage if they don't exist locally. If set, the command deletes files that exist in the stage, but not in the local filesystem. This option cannot be used when paths are specified.""",
-    ),
-    recursive: Optional[bool] = typer.Option(
-        None,
-        "--recursive/--no-recursive",
-        "-r",
-        help=f"""Whether to traverse and deploy files from subdirectories. If set, the command deploys all files and subdirectories; otherwise, only files in the current directory are deployed.""",
-    ),
-    paths: Optional[List[Path]] = typer.Argument(
-        default=None,
-        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
-            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."""
-        ).strip(),
-    ),
-    from_release_directive: Optional[bool] = typer.Option(
-        False,
-        "--from-release-directive",
-        help=f"""Creates or upgrades an application object to the version and patch specified by the release directive applicable to your Snowflake account.
-        The command fails if no release directive exists for your Snowflake account for a given application package, which is determined from the project definition file. Default: unset.""",
-        is_flag=True,
-    ),
-    interactive: bool = InteractiveOption,
-    force: Optional[bool] = ForceOption,
-    validate: bool = ValidateOption,
-    **options,
-):
-    """
-    Deploys the specified entity.
-    """
-    if prune is None and recursive is None and not paths:
-        prune = True
-        recursive = True
-    else:
-        if prune is None:
-            prune = False
-        if recursive is None:
-            recursive = False
-
-    if paths and prune:
-        raise IncompatibleParametersError(["paths", "--prune"])
-
-    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.DEPLOY,
-        prune=prune,
-        recursive=recursive,
-        paths=paths,
-        validate=validate,
-        from_release_directive=from_release_directive,
-        interactive=interactive,
-        force=force,
-    )
-    return MessageResult("Deployed successfully.")
-
-
-@ws.command(requires_connection=True, hidden=True)
-@with_project_definition()
-def drop(
-    entity_id: str = typer.Option(
-        help=f"""The ID of the entity you want to drop.""",
-    ),
-    # TODO The following options should be generated automatically, depending on the specified entity type
-    interactive: bool = InteractiveOption,
-    force: Optional[bool] = ForceOption,
-    cascade: Optional[bool] = typer.Option(
-        None,
-        help=f"""Whether to drop all application objects owned by the application within the account. Default: false.""",
-        show_default=False,
-    ),
-    **options,
-):
-    """
-    Drops the specified entity.
-    """
-    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.DROP,
-        force_drop=force,
-        interactive=interactive,
-        cascade=cascade,
-    )
-
-
-@ws.command(requires_connection=True, hidden=True)
-@with_project_definition()
-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."""
-    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.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/manager.py

@@ -1,74 +0,0 @@
-from pathlib import Path
-from typing import Dict
-
-from snowflake.cli._plugins.workspace.action_context import ActionContext
-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.exceptions import InvalidProjectDefinitionVersionError
-from snowflake.cli.api.project.definition import default_role
-from snowflake.cli.api.project.schemas.entities.entities import (
-    Entity,
-    v2_entity_model_to_entity_map,
-)
-from snowflake.cli.api.project.schemas.project_definition import (
-    DefinitionV20,
-    ProjectDefinition,
-)
-from snowflake.cli.api.project.util import to_identifier
-
-
-class WorkspaceManager:
-    """
-    Instantiates entity instances from entity models, providing higher-order functionality on entity compositions.
-    """
-
-    def __init__(self, project_definition: ProjectDefinition, project_root: Path):
-        if not project_definition.meets_version_requirement("2"):
-            raise InvalidProjectDefinitionVersionError(
-                "2.x", project_definition.definition_version
-            )
-        self._entities_cache: Dict[str, Entity] = {}
-        self._project_definition: DefinitionV20 = project_definition
-        self._project_root = project_root
-        self._default_role = default_role()
-        if self._default_role is None:
-            self._default_role = get_sql_executor().current_role()
-        self.default_warehouse = None
-        cli_context = get_cli_context()
-        if cli_context.connection.warehouse:
-            self.default_warehouse = to_identifier(cli_context.connection.warehouse)
-
-    def get_entity(self, entity_id: str):
-        """
-        Returns an entity instance with the given ID. If exists, reuses the previously returned instance, or instantiates a new one otherwise.
-        """
-        if entity_id in self._entities_cache:
-            return self._entities_cache[entity_id]
-        entity_model = self._project_definition.entities.get(entity_id, None)
-        if entity_model is None:
-            raise ValueError(f"No such entity ID: {entity_id}")
-        entity_model_cls = entity_model.__class__
-        entity_cls = v2_entity_model_to_entity_map[entity_model_cls]
-        self._entities_cache[entity_id] = entity_cls(entity_model)
-        return self._entities_cache[entity_id]
-
-    def perform_action(self, entity_id: str, action: EntityActions, *args, **kwargs):
-        """
-        Instantiates an entity of the given ID and calls the given action on it.
-        """
-        entity = self.get_entity(entity_id)
-        if entity.supports(action):
-            action_ctx = ActionContext(
-                console=cc,
-                project_root=self.project_root(),
-                default_role=self._default_role,
-                default_warehouse=self.default_warehouse,
-                get_entity=self.get_entity,
-            )
-            return entity.perform(action, action_ctx, *args, **kwargs)
-        else:
-            raise ValueError(f'This entity type does not support "{action.value}"')
-
-    def project_root(self) -> Path:
-        return self._project_root

snowflake/cli/_plugins/workspace/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.workspace 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.ws.create_instance(),
-    )

snowflake/cli/api/__init__.py

@@ -1,48 +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
-
-from typing import Optional
-
-from snowflake.cli.api.plugins.plugin_config import PluginConfigProvider
-
-
-class Api:
-    def __init__(
-        self,
-        plugin_config_provider: PluginConfigProvider,
-    ):
-        self.plugin_config_provider = plugin_config_provider
-
-
-class ApiNotInitializedError(RuntimeError):
-    """There was a try to use CLI's API while it is still not initialized."""
-
-
-class ApiProvider:
-    def __init__(self):
-        self._api: Optional[Api] = None
-
-    def register_api(self, api: Api) -> None:
-        self._api = api
-
-    def api(self) -> Api:
-        if self._api:
-            return self._api
-        else:
-            raise ApiNotInitializedError()
-
-
-api_provider = ApiProvider()