snowflake-cli 3.10.0__py3-none-any.whl → 3.11.0__py3-none-any.whl

snowflake/cli/_plugins/auth/oidc/manager.py

@@ -0,0 +1,66 @@
+# 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.
+
+import logging
+from typing import TypeAlias
+
+from snowflake.cli._app.auth.errors import OidcProviderError
+from snowflake.cli._app.auth.oidc_providers import (
+    OidcProviderType,
+    OidcProviderTypeWithAuto,
+    auto_detect_oidc_provider,
+    get_active_oidc_provider,
+)
+from snowflake.cli.api.exceptions import CliError
+
+logger = logging.getLogger(__name__)
+
+
+Providers: TypeAlias = OidcProviderType | OidcProviderTypeWithAuto
+
+
+class OidcManager:
+    """
+    Manages OIDC authentication.
+
+    This class provides methods to read OIDC configurations for authentication.
+    """
+
+    def read_token(
+        self,
+        provider_type: Providers = OidcProviderTypeWithAuto.AUTO,
+    ) -> str:
+        """
+        Reads OIDC token based on the specified provider type.
+
+        Args:
+            provider_type: Type of provider to read token from ("auto" for auto-detection)
+
+        Returns:
+            Token string or provider information
+
+        Raises:
+            CliError: If token reading fails
+        """
+        logger.info("Reading OIDC token with provider type: %s", provider_type)
+
+        try:
+            if provider_type == OidcProviderTypeWithAuto.AUTO:
+                provider = auto_detect_oidc_provider()
+            else:
+                provider = get_active_oidc_provider(provider_type.value)
+            return provider.get_token()
+        except OidcProviderError as e:
+            logger.error("OIDC provider error: %s", str(e))
+            raise CliError(str(e))

snowflake/cli/_plugins/auth/oidc/plugin_spec.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 snowflake.cli._plugins.auth import app
+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=app.create_instance(),
+    )

snowflake/cli/_plugins/connection/commands.py

@@ -53,6 +53,7 @@ from snowflake.cli.api.commands.flags import (
     TokenFilePathOption,
     UserOption,
     WarehouseOption,
+    WorkloadIdentityProviderOption,
 )
 from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.config import (
@@ -62,7 +63,9 @@ from snowflake.cli.api.config import (
     get_all_connections,
     get_connection_dict,
     get_default_connection_name,
+    remove_connection_from_proper_file,
     set_config_value,
+    unset_config_value,
 )
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
@@ -220,6 +223,12 @@ def add(
         *AuthenticatorOption.param_decls,
         help="Chosen authenticator, if other than password-based",
     ),
+    workload_identity_provider: Optional[str] = typer.Option(
+        None,
+        "-W",
+        *WorkloadIdentityProviderOption.param_decls,
+        help="Workload identity provider type",
+    ),
     private_key_file: Optional[str] = typer.Option(
         None,
         "--private-key",
@@ -256,6 +265,7 @@ def add(
         "port": port,
         "region": region,
         "authenticator": authenticator,
+        "workload_identity_provider": workload_identity_provider,
         "private_key_file": private_key_file,
         "token_file_path": token_file_path,
     }
@@ -317,6 +327,30 @@ def add(
     )
 
 
+@app.command(requires_connection=False)
+def remove(
+    connection_name: str = typer.Argument(
+        help="Name of the connection to remove.",
+        show_default=False,
+    ),
+    **options,
+):
+    """Removes a connection from configuration file."""
+    if not connection_exists(connection_name):
+        raise UsageError(f"Connection {connection_name} does not exist.")
+
+    is_default = get_default_connection_name() == connection_name
+    if is_default:
+        unset_config_value(path=["default_connection_name"])
+
+    connections_file = remove_connection_from_proper_file(connection_name)
+
+    return MessageResult(
+        f"Removed connection {connection_name} from {connections_file}."
+        f"{' It was the default connection, so default connection is now unset.' if is_default else ''}"
+    )
+
+
 @app.command(requires_connection=True)
 def test(
     **options,
@@ -355,9 +389,9 @@ def test(
         "Host": conn.host,
         "Account": conn.account,
         "User": conn.user,
-        "Role": f'{conn.role or "not set"}',
-        "Database": f'{conn.database or "not set"}',
-        "Warehouse": f'{conn.warehouse or "not set"}',
+        "Role": f"{conn.role or 'not set'}",
+        "Database": f"{conn.database or 'not set'}",
+        "Warehouse": f"{conn.warehouse or 'not set'}",
     }
 
     if conn_ctx.enable_diag:

snowflake/cli/_plugins/dbt/manager.py

@@ -44,7 +44,7 @@ class DBTManager(SqlExecutionMixin):
 
     def deploy(
         self,
-        name: FQN,
+        fqn: FQN,
         path: SecurePath,
         profiles_path: SecurePath,
         force: bool,
@@ -66,7 +66,7 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating temporary stage"):
             stage_manager = StageManager()
-            stage_fqn = FQN.from_string(f"dbt_{name}_stage").using_context()
+            stage_fqn = FQN.from_string(f"dbt_{fqn.name}_stage").using_context()
             stage_name = stage_manager.get_standard_stage_prefix(stage_fqn)
             stage_manager.create(stage_fqn, temporary=True)
 
@@ -86,11 +86,11 @@ class DBTManager(SqlExecutionMixin):
 
         with cli_console.phase("Creating DBT project"):
             if force is True:
-                query = f"CREATE OR REPLACE DBT PROJECT {name}"
-            elif self.exists(name=name):
-                query = f"ALTER DBT PROJECT {name} ADD VERSION"
+                query = f"CREATE OR REPLACE DBT PROJECT {fqn}"
+            elif self.exists(name=fqn):
+                query = f"ALTER DBT PROJECT {fqn} ADD VERSION"
             else:
-                query = f"CREATE DBT PROJECT {name}"
+                query = f"CREATE DBT PROJECT {fqn}"
             query += f"\nFROM {stage_name}"
             return self.execute_query(query)
 
@@ -174,7 +174,7 @@ class DBTManager(SqlExecutionMixin):
             yaml.safe_dump(yaml.safe_load(sfd), tfd)
 
     def execute(
-        self, dbt_command: str, name: str, run_async: bool, *dbt_cli_args
+        self, dbt_command: str, name: FQN, run_async: bool, *dbt_cli_args
     ) -> SnowflakeCursor:
         if dbt_cli_args:
             dbt_command = " ".join([dbt_command, *dbt_cli_args]).strip()

snowflake/cli/_plugins/{project → dcm}/commands.py

@@ -11,24 +11,23 @@
 # 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 List, Optional
 
 import typer
+from snowflake.cli._plugins.dcm.dcm_project_entity_model import (
+    DCMProjectEntityModel,
+)
+from snowflake.cli._plugins.dcm.manager import DCMProjectManager
 from snowflake.cli._plugins.object.command_aliases import add_object_command_aliases
 from snowflake.cli._plugins.object.commands import scope_option
 from snowflake.cli._plugins.object.manager import ObjectManager
-from snowflake.cli._plugins.project.manager import ProjectManager
-from snowflake.cli._plugins.project.project_entity_model import (
-    ProjectEntityModel,
-)
+from snowflake.cli.api.artifacts.upload import sync_artifacts_with_stage
 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.flags import (
     IfExistsOption,
     IfNotExistsOption,
     OverrideableOption,
-    PruneOption,
     entity_argument,
     identifier_argument,
     like_option,
@@ -46,99 +45,130 @@ from snowflake.cli.api.output.types import (
     QueryJsonValueResult,
     QueryResult,
 )
+from snowflake.cli.api.project.project_paths import ProjectPaths
 
 app = SnowTyperFactory(
-    name="project",
-    help="Manages projects in Snowflake.",
+    name="dcm",
+    help="Manages DCM Projects in Snowflake.",
     is_hidden=FeatureFlag.ENABLE_SNOWFLAKE_PROJECTS.is_disabled,
 )
 
-project_identifier = identifier_argument(sf_object="project", example="MY_PROJECT")
-version_flag = typer.Option(
-    None,
-    "--version",
-    help="Version of the project to use. If not specified default version is used. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
-    show_default=False,
-)
+dcm_identifier = identifier_argument(sf_object="DCM Project", example="MY_PROJECT")
 variables_flag = variables_option(
     'Variables for the execution context; for example: `-D "<key>=<value>"`.'
 )
 configuration_flag = typer.Option(
     None,
     "--configuration",
-    help="Configuration of the project to use. If not specified default configuration is used.",
+    help="Configuration of the DCM Project to use. If not specified default configuration is used.",
     show_default=False,
 )
 from_option = OverrideableOption(
     None,
     "--from",
+    mutually_exclusive=["prune"],
+    show_default=False,
+)
+
+prune_option = OverrideableOption(
+    False,
+    "--prune",
+    help="Remove unused artifacts from the stage during sync. Mutually exclusive with --from.",
+    mutually_exclusive=["from_stage"],
+    show_default=False,
+)
+
+alias_option = typer.Option(
+    None,
+    "--alias",
+    help="Alias for the deployment.",
+    show_default=False,
+)
+output_path_option = OverrideableOption(
+    None,
+    "--output-path",
+    show_default=False,
+)
+
+terse_option = typer.Option(
+    False,
+    "--terse",
+    help="Returns only a subset of output columns.",
+    show_default=False,
+)
+
+limit_option = typer.Option(
+    None,
+    "--limit",
+    help="Limits the maximum number of rows returned.",
     show_default=False,
 )
 
 
 add_object_command_aliases(
     app=app,
-    object_type=ObjectType.PROJECT,
-    name_argument=project_identifier,
+    object_type=ObjectType.DCM_PROJECT,
+    name_argument=dcm_identifier,
     like_option=like_option(
-        help_example='`list --like "my%"` lists all projects that begin with "my"'
+        help_example='`list --like "my%"` lists all DCM Projects that begin with "my"'
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
-    ommit_commands=["create", "describe"],
+    ommit_commands=["create"],
+    terse_option=terse_option,
+    limit_option=limit_option,
 )
 
 
 @app.command(requires_connection=True)
-def execute(
-    identifier: FQN = project_identifier,
-    version: Optional[str] = version_flag,
+def deploy(
+    identifier: FQN = dcm_identifier,
     from_stage: Optional[str] = from_option(
-        help="Execute project from given stage instead of using a specific version."
+        help="Deploy DCM Project deployment from a given stage."
     ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    alias: Optional[str] = alias_option,
+    prune: bool = prune_option(),
     **options,
 ):
     """
-    Executes a project.
+    Applies changes defined in DCM Project to Snowflake.
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
-
-    result = ProjectManager().execute(
+    result = DCMProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
-        version=version,
-        from_stage=from_stage,
+        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
         variables=variables,
+        alias=alias,
+        output_path=None,
     )
     return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
-def dry_run(
-    identifier: FQN = project_identifier,
-    version: Optional[str] = version_flag,
+def plan(
+    identifier: FQN = dcm_identifier,
     from_stage: Optional[str] = from_option(
-        help="Execute project from given stage instead of using a specific version."
+        help="Plan DCM Project deployment from a given stage."
     ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
+    prune: bool = prune_option(),
+    output_path: Optional[str] = output_path_option(
+        help="Stage path where the deployment plan output will be stored."
+    ),
     **options,
 ):
     """
-    Validates a project.
+    Plans a DCM Project deployment (validates without executing).
     """
-    if version and from_stage:
-        raise CliError("--version and --from are mutually exclusive.")
-
-    result = ProjectManager().execute(
+    result = DCMProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
-        version=version,
-        from_stage=from_stage,
+        from_stage=from_stage if from_stage else _sync_local_files(prune=prune),
         dry_run=True,
         variables=variables,
+        output_path=output_path,
     )
     return QueryJsonValueResult(result)
 
@@ -146,114 +176,55 @@ def dry_run(
 @app.command(requires_connection=True)
 @with_project_definition()
 def create(
-    entity_id: str = entity_argument("project"),
-    no_version: bool = typer.Option(
-        False,
-        "--no-version",
-        help="Do not initialize project with a new version, only create the snowflake object.",
-    ),
+    entity_id: str = entity_argument("dcm"),
     if_not_exists: bool = IfNotExistsOption(
         help="Do nothing if the project already exists."
     ),
     **options,
 ):
     """
-    Creates a project in Snowflake.
-    By default, the project is initialized with a new version created from local files.
+    Creates a DCM Project in Snowflake.
     """
     cli_context = get_cli_context()
-    project: ProjectEntityModel = get_entity_for_operation(
+    project: DCMProjectEntityModel = get_entity_for_operation(
         cli_context=cli_context,
         entity_id=entity_id,
         project_definition=cli_context.project_definition,
-        entity_type="project",
+        entity_type="dcm",
     )
     om = ObjectManager()
-    if om.object_exists(object_type="project", fqn=project.fqn):
-        message = f"Project '{project.fqn}' already exists."
+    if om.object_exists(object_type="dcm", fqn=project.fqn):
+        message = f"DCM Project '{project.fqn}' already exists."
         if if_not_exists:
             return MessageResult(message)
         raise CliError(message)
 
-    if not no_version and om.object_exists(
-        object_type="stage", fqn=FQN.from_stage(project.stage)
-    ):
+    if om.object_exists(object_type="stage", fqn=FQN.from_stage(project.stage)):
         raise CliError(f"Stage '{project.stage}' already exists.")
 
-    pm = ProjectManager()
-    with cli_console.phase(f"Creating project '{project.fqn}'"):
-        pm.create(project=project, initialize_version_from_local_files=not no_version)
+    dpm = DCMProjectManager()
+    with cli_console.phase(f"Creating DCM Project '{project.fqn}'"):
+        dpm.create(project=project)
 
-    if no_version:
-        return MessageResult(f"Project '{project.fqn}' successfully created.")
-    return MessageResult(
-        f"Project '{project.fqn}' successfully created and initial version is added."
-    )
+    return MessageResult(f"DCM Project '{project.fqn}' successfully created.")
 
 
 @app.command(requires_connection=True)
-@with_project_definition()
-def add_version(
-    entity_id: str = entity_argument("project"),
-    _from: Optional[str] = from_option(
-        help="Create a new version using given stage instead of uploading local files."
-    ),
-    _alias: Optional[str] = typer.Option(
-        None, "--alias", help="Alias for the version.", show_default=False
-    ),
-    comment: Optional[str] = typer.Option(
-        None, "--comment", help="Version comment.", show_default=False
-    ),
-    prune: bool = PruneOption(default=True),
-    **options,
-):
-    """Uploads local files to Snowflake and cerates a new project version."""
-    if _from is not None and prune:
-        cli_console.warning(
-            "When `--from` option is used, `--prune` option will be ignored and files from stage will be used as they are."
-        )
-        prune = False
-    cli_context = get_cli_context()
-    project: ProjectEntityModel = get_entity_for_operation(
-        cli_context=cli_context,
-        entity_id=entity_id,
-        project_definition=cli_context.project_definition,
-        entity_type="project",
-    )
-    om = ObjectManager()
-    if not om.object_exists(object_type="project", fqn=project.fqn):
-        raise CliError(
-            f"Project '{project.fqn}' does not exist. Use `project create` command first."
-        )
-    ProjectManager().add_version(
-        project=project,
-        prune=prune,
-        from_stage=_from,
-        alias=_alias,
-        comment=comment,
-    )
-    alias_str = "" if _alias is None else f"'{_alias}' "
-    return MessageResult(
-        f"New project version {alias_str}added to project '{project.fqn}'."
-    )
-
-
-@app.command(requires_connection=True)
-def list_versions(
-    identifier: FQN = project_identifier,
+def list_deployments(
+    identifier: FQN = dcm_identifier,
     **options,
 ):
     """
-    Lists versions of given project.
+    Lists deployments of given DCM Project.
     """
-    pm = ProjectManager()
+    pm = DCMProjectManager()
     results = pm.list_versions(project_name=identifier)
     return QueryResult(results)
 
 
 @app.command(requires_connection=True)
-def drop_version(
-    identifier: FQN = project_identifier,
+def drop_deployment(
+    identifier: FQN = dcm_identifier,
     version_name: str = typer.Argument(
         help="Name or alias of the version to drop. For names containing '$', use single quotes to prevent shell expansion (e.g., 'VERSION$1').",
         show_default=False,
@@ -262,7 +233,7 @@ def drop_version(
     **options,
 ):
     """
-    Drops a version from the project.
+    Drops a version from the DCM Project.
     """
     # Detect potential shell expansion issues
     if version_name and version_name.upper() == "VERSION":
@@ -271,12 +242,32 @@ def drop_version(
             f"If you meant to use a version like 'VERSION$1', try using single quotes: 'VERSION$1'."
         )
 
-    pm = ProjectManager()
-    pm.drop_version(
+    dpm = DCMProjectManager()
+    dpm.drop_deployment(
         project_name=identifier,
         version_name=version_name,
         if_exists=if_exists,
     )
     return MessageResult(
-        f"Version '{version_name}' dropped from project '{identifier}'."
+        f"Version '{version_name}' dropped from DCM Project '{identifier}'."
+    )
+
+
+def _sync_local_files(prune: bool = False) -> str:
+    cli_context = get_cli_context()
+    project_entity = get_entity_for_operation(
+        cli_context=cli_context,
+        entity_id=None,
+        project_definition=cli_context.project_definition,
+        entity_type="dcm",
     )
+
+    with cli_console.phase("Syncing local files to stage"):
+        sync_artifacts_with_stage(
+            project_paths=ProjectPaths(project_root=cli_context.project_root),
+            stage_root=project_entity.stage,
+            artifacts=project_entity.artifacts,
+            prune=prune,
+        )
+
+    return project_entity.stage

snowflake/cli/_plugins/{project/project_entity_model.py → dcm/dcm_project_entity_model.py}

@@ -35,10 +35,10 @@ T = TypeVar("T")
 MANIFEST_FILE_NAME = "manifest.yml"
 
 
-class ProjectEntityModel(EntityModelBaseWithArtifacts):
-    type: Literal["project"] = DiscriminatorField()  # noqa: A003
+class DCMProjectEntityModel(EntityModelBaseWithArtifacts):
+    type: Literal["dcm"] = DiscriminatorField()  # noqa: A003
     stage: Optional[str] = Field(
-        title="Stage in which the project artifacts will be stored", default=None
+        title="Stage in which the DCM Project artifacts will be stored", default=None
     )
 
     @field_validator("artifacts")
@@ -54,6 +54,6 @@ class ProjectEntityModel(EntityModelBaseWithArtifacts):
         return super().transform_artifacts(orig_artifacts)
 
 
-@attach_spans_to_entity_actions(entity_name="project")
-class ProjectEntity(EntityBase[ProjectEntityModel]):
+@attach_spans_to_entity_actions(entity_name="dcm")
+class DCMProjectEntity(EntityBase[DCMProjectEntityModel]):
     """Placeholder for project entity"""