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

snowflake/cli/_plugins/project/commands.py

@@ -18,7 +18,6 @@ import typer
 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.feature_flags import FeatureFlag
 from snowflake.cli._plugins.project.manager import ProjectManager
 from snowflake.cli._plugins.project.project_entity_model import (
     ProjectEntityModel,
@@ -26,6 +25,7 @@ from snowflake.cli._plugins.project.project_entity_model import (
 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,
@@ -39,8 +39,13 @@ from snowflake.cli.api.commands.utils import get_entity_for_operation
 from snowflake.cli.api.console.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import CliError
+from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.types import MessageResult, QueryResult, SingleQueryResult
+from snowflake.cli.api.output.types import (
+    MessageResult,
+    QueryJsonValueResult,
+    QueryResult,
+)
 
 app = SnowTyperFactory(
     name="project",
@@ -52,7 +57,7 @@ project_identifier = identifier_argument(sf_object="project", example="MY_PROJEC
 version_flag = typer.Option(
     None,
     "--version",
-    help="Version of the project to use. If not specified default version is used",
+    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,
 )
 variables_flag = variables_option(
@@ -67,7 +72,6 @@ configuration_flag = typer.Option(
 from_option = OverrideableOption(
     None,
     "--from",
-    help="Create a new version using given stage instead of uploading local files.",
     show_default=False,
 )
 
@@ -77,7 +81,7 @@ add_object_command_aliases(
     object_type=ObjectType.PROJECT,
     name_argument=project_identifier,
     like_option=like_option(
-        help_example='`list --like "my%"` lists all projects that begin with “my”'
+        help_example='`list --like "my%"` lists all projects that begin with "my"'
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
     ommit_commands=["create", "describe"],
@@ -88,6 +92,9 @@ add_object_command_aliases(
 def execute(
     identifier: FQN = project_identifier,
     version: Optional[str] = version_flag,
+    from_stage: Optional[str] = from_option(
+        help="Execute project from given stage instead of using a specific version."
+    ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
     **options,
@@ -95,19 +102,26 @@ def execute(
     """
     Executes a project.
     """
+    if version and from_stage:
+        raise CliError("--version and --from are mutually exclusive.")
+
     result = ProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
         version=version,
+        from_stage=from_stage,
         variables=variables,
     )
-    return SingleQueryResult(result)
+    return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
 def dry_run(
     identifier: FQN = project_identifier,
     version: Optional[str] = version_flag,
+    from_stage: Optional[str] = from_option(
+        help="Execute project from given stage instead of using a specific version."
+    ),
     variables: Optional[List[str]] = variables_flag,
     configuration: Optional[str] = configuration_flag,
     **options,
@@ -115,14 +129,18 @@ def dry_run(
     """
     Validates a project.
     """
+    if version and from_stage:
+        raise CliError("--version and --from are mutually exclusive.")
+
     result = ProjectManager().execute(
         project_name=identifier,
         configuration=configuration,
         version=version,
+        from_stage=from_stage,
         dry_run=True,
         variables=variables,
     )
-    return SingleQueryResult(result)
+    return QueryJsonValueResult(result)
 
 
 @app.command(requires_connection=True)
@@ -177,7 +195,9 @@ def create(
 @with_project_definition()
 def add_version(
     entity_id: str = entity_argument("project"),
-    _from: Optional[str] = from_option(),
+    _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
     ),
@@ -203,7 +223,7 @@ def add_version(
     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"
+            f"Project '{project.fqn}' does not exist. Use `project create` command first."
         )
     ProjectManager().add_version(
         project=project,
@@ -214,7 +234,7 @@ def add_version(
     )
     alias_str = "" if _alias is None else f"'{_alias}' "
     return MessageResult(
-        f"New project version {alias_str}added to project '{project.fqn}'"
+        f"New project version {alias_str}added to project '{project.fqn}'."
     )
 
 
@@ -229,3 +249,34 @@ def list_versions(
     pm = ProjectManager()
     results = pm.list_versions(project_name=identifier)
     return QueryResult(results)
+
+
+@app.command(requires_connection=True)
+def drop_version(
+    identifier: FQN = project_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,
+    ),
+    if_exists: bool = IfExistsOption(help="Do nothing if the version does not exist."),
+    **options,
+):
+    """
+    Drops a version from the project.
+    """
+    # Detect potential shell expansion issues
+    if version_name and version_name.upper() == "VERSION":
+        cli_console.warning(
+            f"Version name '{version_name}' might be truncated due to shell expansion. "
+            f"If you meant to use a version like 'VERSION$1', try using single quotes: 'VERSION$1'."
+        )
+
+    pm = ProjectManager()
+    pm.drop_version(
+        project_name=identifier,
+        version_name=version_name,
+        if_exists=if_exists,
+    )
+    return MessageResult(
+        f"Version '{version_name}' dropped from project '{identifier}'."
+    )

snowflake/cli/_plugins/project/manager.py

@@ -33,6 +33,7 @@ class ProjectManager(SqlExecutionMixin):
         project_name: FQN,
         configuration: str | None = None,
         version: str | None = None,
+        from_stage: str | None = None,
         variables: List[str] | None = None,
         dry_run: bool = False,
     ):
@@ -47,6 +48,9 @@ class ProjectManager(SqlExecutionMixin):
             ).removeprefix(" using")
         if version:
             query += f" WITH VERSION {version}"
+        elif from_stage:
+            stage_path = StagePath.from_stage_str(from_stage)
+            query += f" FROM {stage_path.absolute_path()}"
         if dry_run:
             query += " DRY_RUN=TRUE"
         return self.execute_query(query=query)
@@ -72,7 +76,7 @@ class ProjectManager(SqlExecutionMixin):
         stage_path = StagePath.from_stage_str(from_stage)
         query = f"ALTER PROJECT {project_name.identifier} ADD VERSION"
         if alias:
-            query += f' IF NOT EXISTS "{alias}"'
+            query += f" IF NOT EXISTS {alias}"
         query += f" FROM {stage_path.absolute_path(at_prefix=True)}"
         if comment:
             query += f" COMMENT = '{comment}'"
@@ -113,3 +117,18 @@ class ProjectManager(SqlExecutionMixin):
     def list_versions(self, project_name: FQN):
         query = f"SHOW VERSIONS IN PROJECT {project_name.identifier}"
         return self.execute_query(query=query)
+
+    def drop_version(
+        self,
+        project_name: FQN,
+        version_name: str,
+        if_exists: bool = False,
+    ):
+        """
+        Drops a version from the project.
+        """
+        query = f"ALTER PROJECT {project_name.identifier} DROP VERSION"
+        if if_exists:
+            query += " IF EXISTS"
+        query += f" {version_name}"
+        return self.execute_query(query=query)

snowflake/cli/_plugins/snowpark/common.py

@@ -79,7 +79,6 @@ class SnowparkObjectManager(SqlExecutionMixin):
     ) -> str:
         entity.imports.extend(artifact_files)
         imports = [f"'{x}'" for x in entity.imports]
-        packages_list = ",".join(f"'{p}'" for p in snowflake_dependencies)
 
         object_type = entity.get_type()
 
@@ -91,7 +90,6 @@ class SnowparkObjectManager(SqlExecutionMixin):
             f"runtime_version={entity.runtime or DEFAULT_RUNTIME}",
             f"imports=({', '.join(imports)})",
             f"handler='{entity.handler}'",
-            f"packages=({packages_list})",
         ]
 
         if entity.external_access_integrations:
@@ -100,17 +98,24 @@ class SnowparkObjectManager(SqlExecutionMixin):
         if entity.secrets:
             query.append(entity.get_secrets_sql())
 
-        if isinstance(entity, ProcedureEntityModel) and entity.execute_as_caller:
-            query.append("execute as caller")
+        if entity.artifact_repository_packages and entity.packages:
+            raise UsageError(
+                "You cannot specify both artifact_repository_packages and packages.",
+            )
 
-        if entity.artifact_repository and entity.artifact_repository_packages:
-            packages = [f"'{item}'" for item in entity.artifact_repository_packages]
-            query.extend(
-                [
-                    f"ARTIFACT_REPOSITORY= {entity.artifact_repository}",
-                    f"ARTIFACT_REPOSITORY_PACKAGES=({','.join(packages)})",
-                ]
+        packages_list = snowflake_dependencies.copy()
+        if entity.artifact_repository and (
+            entity.artifact_repository_packages or entity.packages
+        ):
+            if entity.artifact_repository_packages:
+                packages_list.extend(entity.artifact_repository_packages)
+            else:
+                packages_list.extend(entity.packages)
+            query.append(
+                f"ARTIFACT_REPOSITORY= {entity.artifact_repository}",
             )
+        packages = [f"'{item}'" for item in packages_list]
+        query.append(f"packages=({','.join(packages)})")
 
         if entity.resource_constraint:
             constraints = ",".join(
@@ -118,6 +123,9 @@ class SnowparkObjectManager(SqlExecutionMixin):
             )
             query.append(f"RESOURCE_CONSTRAINT=({constraints})")
 
+        if isinstance(entity, ProcedureEntityModel) and entity.execute_as_caller:
+            query.append("execute as caller")
+
         return self.execute_query("\n".join(query))
 
     def deploy_entity(
@@ -215,6 +223,10 @@ def _check_if_replace_is_required(
         )
         return True
 
+    if entity.packages != resource_json.get("artifact_repository_packages", None):
+        log.info("Packages do not match. Replacing the %s", object_type)
+        return True
+
     if isinstance(entity, ProcedureEntityModel):
         if resource_json.get("execute as", "OWNER") != (
             "CALLER" if entity.execute_as_caller else "OWNER"

snowflake/cli/_plugins/snowpark/snowpark_entity.py

@@ -173,20 +173,28 @@ class SnowparkEntity(EntityBase[Generic[T]]):
         if self.model.secrets:
             query.append(self.model.get_secrets_sql())
 
-        if self.model.type == "procedure" and self.model.execute_as_caller:
-            query.append("EXECUTE AS CALLER")
+        if self.model.artifact_repository and (
+            self.model.artifact_repository_packages or self.model.packages
+        ):
+            if self.model.artifact_repository_packages:
+                packages = [
+                    f"'{item}'" for item in self.model.artifact_repository_packages
+                ]
+            else:
+                packages = [f"'{item}'" for item in self.model.packages]
 
-        if self.model.artifact_repository and self.model.artifact_repository_packages:
-            packages = [f"'{item}'" for item in self.model.artifact_repository_packages]
             query.extend(
                 [
                     f"ARTIFACT_REPOSITORY= {self.model.artifact_repository} ",
-                    f"ARTIFACT_REPOSITORY_PACKAGES=({','.join(packages)})",
+                    f"PACKAGES=({','.join(packages)})",
                 ]
             )
         if self.model.resource_constraint:
             query.append(self._get_resource_constraints_sql())
 
+        if self.model.type == "procedure" and self.model.execute_as_caller:
+            query.append("EXECUTE AS CALLER")
+
         return "\n".join(query)
 
     def get_execute_sql(self, execution_arguments: List[str] | None = None):

snowflake/cli/_plugins/snowpark/snowpark_entity_model.py

@@ -54,6 +54,9 @@ class SnowparkEntityModel(
         default=None, title="Artifact repository to be used"
     )
     artifact_repository_packages: Optional[List[str]] = Field(
+        default=None, title="Alias for packages"
+    )
+    packages: Optional[List[str]] = Field(
         default=None, title="Packages to be installed from artifact repository"
     )
 
@@ -91,9 +94,14 @@ class SnowparkEntityModel(
     def check_artifact_repository(cls, values: dict) -> dict:
         artifact_repository = values.get("artifact_repository")
         artifact_repository_packages = values.get("artifact_repository_packages")
-        if artifact_repository_packages and not artifact_repository:
+        packages = values.get("packages")
+        if artifact_repository_packages and packages:
+            raise ValueError(
+                "You cannot specify both artifact_repository_packages and packages.",
+            )
+        if (artifact_repository_packages or packages) and not artifact_repository:
             raise ValueError(
-                "You specified Artifact_repository_packages without setting Artifact_repository.",
+                "You specified packages / artifact_repository_packages without setting artifact_repository.",
             )
         return values
 

snowflake/cli/_plugins/spcs/image_registry/commands.py

@@ -64,10 +64,10 @@ def url(private_link: bool = PrivateLinkOption, **options) -> MessageResult:
 
 
 @app.command(requires_connection=True)
-def login(**options) -> MessageResult:
+def login(private_link: bool = PrivateLinkOption, **options) -> MessageResult:
     """
     Logs in to the account image registry with the current user's credentials through Docker.
 
     Must be called from a role that can view at least one image repository in the image registry.
     """
-    return MessageResult(RegistryManager().docker_registry_login().strip())
+    return MessageResult(RegistryManager().docker_registry_login(private_link).strip())

snowflake/cli/_plugins/spcs/image_registry/manager.py

@@ -101,8 +101,8 @@ class RegistryManager(SqlExecutionMixin):
             sample_repository_url = f"//{sample_repository_url}"
         return urlparse(sample_repository_url).netloc
 
-    def docker_registry_login(self) -> str:
-        registry_url = self.get_registry_url()
+    def docker_registry_login(self, private_link: bool = False) -> str:
+        registry_url = self.get_registry_url(private_link)
         token = self.get_token()
         command = [
             "docker",

snowflake/cli/_plugins/sql/commands.py

@@ -15,11 +15,13 @@
 from __future__ import annotations
 
 import sys
+from enum import Enum
 from logging import getLogger
 from pathlib import Path
 from typing import List, Optional
 
 import typer
+from click import UsageError
 from snowflake.cli._plugins.sql.manager import SqlManager
 from snowflake.cli.api.commands.decorators import with_project_definition
 from snowflake.cli.api.commands.flags import (
@@ -34,6 +36,7 @@ from snowflake.cli.api.output.types import (
     MultipleResults,
     QueryResult,
 )
+from snowflake.cli.api.rendering.sql_templates import SQLTemplateSyntaxConfig
 
 logger = getLogger(__name__)
 # simple Typer with defaults because it won't become a command group as it contains only one command
@@ -46,6 +49,37 @@ SourceOption = OverrideableOption(
 )
 
 
+class _EnabledTemplating(str, Enum):
+    LEGACY = "LEGACY"
+    STANDARD = "STANDARD"
+    JINJA = "JINJA"
+    ALL = "ALL"
+    NONE = "NONE"
+
+
+def _parse_template_syntax_config(
+    enabled_syntaxes: List[_EnabledTemplating],
+) -> SQLTemplateSyntaxConfig:
+    if (
+        _EnabledTemplating.ALL in enabled_syntaxes
+        or _EnabledTemplating.NONE in enabled_syntaxes
+    ) and len(enabled_syntaxes) > 1:
+        raise UsageError(
+            "ALL and NONE template syntax options should not be used with other options."
+        )
+
+    if _EnabledTemplating.ALL in enabled_syntaxes:
+        return SQLTemplateSyntaxConfig(True, True, True)
+    if _EnabledTemplating.NONE in enabled_syntaxes:
+        return SQLTemplateSyntaxConfig(False, False, False)
+
+    result = SQLTemplateSyntaxConfig()
+    result.enable_legacy_syntax = _EnabledTemplating.LEGACY in enabled_syntaxes
+    result.enable_standard_syntax = _EnabledTemplating.STANDARD in enabled_syntaxes
+    result.enable_jinja_syntax = _EnabledTemplating.JINJA in enabled_syntaxes
+    return result
+
+
 @app.command(name="sql", requires_connection=True, no_args_is_help=False)
 @with_project_definition(is_optional=True)
 def execute_sql(
@@ -83,6 +117,12 @@ def execute_sql(
         flag_value=False,
         is_flag=True,
     ),
+    enabled_templating: List[_EnabledTemplating] = typer.Option(
+        [_EnabledTemplating.LEGACY, _EnabledTemplating.STANDARD],
+        "--enable-templating",
+        help="Syntax used to resolve variables before passing queries to Snowflake.",
+        case_sensitive=False,
+    ),
     **options,
 ) -> CommandResult:
     """
@@ -100,6 +140,8 @@ def execute_sql(
     if data_override:
         data = {v.key: v.value for v in parse_key_value_variables(data_override)}
 
+    template_syntax_config = _parse_template_syntax_config(enabled_templating)
+
     retain_comments = bool(retain_comments)
     single_transaction = bool(single_transaction)
     std_in = bool(std_in)
@@ -116,7 +158,12 @@ def execute_sql(
             raise CliArgumentError("single transaction cannot be used with REPL")
         from snowflake.cli._plugins.sql.repl import Repl
 
-        Repl(SqlManager(), data=data, retain_comments=retain_comments).run()
+        Repl(
+            SqlManager(),
+            data=data,
+            retain_comments=retain_comments,
+            template_syntax_config=template_syntax_config,
+        ).run()
         sys.exit(0)
 
     manager = SqlManager()
@@ -128,6 +175,7 @@ def execute_sql(
         data=data,
         retain_comments=retain_comments,
         single_transaction=single_transaction,
+        template_syntax_config=template_syntax_config,
     )
     if expected_results_cnt == 0:
         # case expected if input only scheduled async queries

snowflake/cli/_plugins/sql/manager.py

@@ -32,7 +32,10 @@ from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.exceptions import CliArgumentError, CliSqlError
 from snowflake.cli.api.output.types import CollectionResult
-from snowflake.cli.api.rendering.sql_templates import snowflake_sql_jinja_render
+from snowflake.cli.api.rendering.sql_templates import (
+    SQLTemplateSyntaxConfig,
+    snowflake_sql_jinja_render,
+)
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.cli.api.sql_execution import SqlExecutionMixin, VerboseCursor
 from snowflake.connector.cursor import SnowflakeCursor
@@ -51,6 +54,7 @@ class SqlManager(SqlExecutionMixin):
         data: Dict | None = None,
         retain_comments: bool = False,
         single_transaction: bool = False,
+        template_syntax_config: SQLTemplateSyntaxConfig = SQLTemplateSyntaxConfig(),
     ) -> Tuple[ExpectedResultsCount, Iterable[SnowflakeCursor]]:
         """Reads, transforms and execute statements from input.
 
@@ -62,9 +66,15 @@ class SqlManager(SqlExecutionMixin):
         """
         query = sys.stdin.read() if std_in else query
 
-        stmt_operators = (
-            transpile_snowsql_templates,
-            partial(snowflake_sql_jinja_render, data=data),
+        stmt_operators = []
+        if template_syntax_config.enable_legacy_syntax:
+            stmt_operators.append(transpile_snowsql_templates)
+        stmt_operators.append(
+            partial(
+                snowflake_sql_jinja_render,
+                template_syntax_config=template_syntax_config,
+                data=data,
+            )
         )
         remove_comments = not retain_comments
 

snowflake/cli/_plugins/sql/repl.py

@@ -13,6 +13,7 @@ from snowflake.cli._plugins.sql.manager import SqlManager
 from snowflake.cli.api.cli_global_context import get_cli_context_manager
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.output.types import MultipleResults, QueryResult
+from snowflake.cli.api.rendering.sql_templates import SQLTemplateSyntaxConfig
 from snowflake.cli.api.secure_path import SecurePath
 from snowflake.connector.config_manager import CONFIG_MANAGER
 from snowflake.connector.cursor import SnowflakeCursor
@@ -35,6 +36,7 @@ class Repl:
         sql_manager: SqlManager,
         data: dict | None = None,
         retain_comments: bool = False,
+        template_syntax_config: SQLTemplateSyntaxConfig = SQLTemplateSyntaxConfig(),
     ):
         """Requires a `SqlManager` instance to execute queries.
 
@@ -46,6 +48,7 @@ class Repl:
         setattr(get_cli_context_manager(), "is_repl", True)
         self._data = data or {}
         self._retain_comments = retain_comments
+        self._template_syntax_config = template_syntax_config
         self._history = FileHistory(HISTORY_FILE)
         self._lexer = PygmentsLexer(CliLexer)
         self._completer = cli_completer
@@ -155,6 +158,7 @@ class Repl:
             std_in=False,
             data=self._data,
             retain_comments=self._retain_comments,
+            template_syntax_config=self._template_syntax_config,
         )
         return cursors
 

snowflake/cli/_plugins/stage/commands.py

@@ -48,7 +48,6 @@ from snowflake.cli.api.commands.snow_typer import SnowTyperFactory
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.output.types import (
     CollectionResult,
     CommandResult,
@@ -74,7 +73,7 @@ add_object_command_aliases(
     object_type=ObjectType.STAGE,
     name_argument=StageNameArgument,
     like_option=like_option(
-        help_example='`list --like "my%"` lists all stages that begin with “my”',
+        help_example='`list --like "my%"` lists all stages that begin with "my"',
     ),
     scope_option=scope_option(help_example="`list --in database my_db`"),
 )
@@ -98,7 +97,7 @@ def copy(
         show_default=False,
     ),
     destination_path: str = typer.Argument(
-        help="Target directory path for copy operation. Should be stage if source is local or local if source is stage.",
+        help="Target directory path for copy operation.",
         show_default=False,
     ),
     overwrite: bool = typer.Option(
@@ -117,19 +116,24 @@ def copy(
         default=False,
         help="Specifies whether Snowflake uses gzip to compress files during upload. Ignored when downloading.",
     ),
+    refresh: bool = typer.Option(
+        default=False,
+        help="Specifies whether ALTER STAGE {name} REFRESH should be executed after uploading.",
+    ),
     **options,
 ) -> CommandResult:
     """
-    Copies all files from target path to target directory. This works for both uploading
-    to and downloading files from the stage.
+    Copies all files from source path to target directory. This works for uploading
+    to and downloading files from the stage, and copying between named stages.
     """
     is_get = is_stage_path(source_path)
     is_put = is_stage_path(destination_path)
 
     if is_get and is_put:
-        raise click.ClickException(
-            "Both source and target path are remote. This operation is not supported."
+        cursor = StageManager().copy_files(
+            source_path=source_path, destination_path=destination_path
         )
+        return QueryResult(cursor)
     if not is_get and not is_put:
         raise click.ClickException(
             "Both source and target path are local. This operation is not supported."
@@ -149,6 +153,7 @@ def copy(
         parallel=parallel,
         overwrite=overwrite,
         auto_compress=auto_compress,
+        refresh=refresh,
     )
 
 
@@ -160,12 +165,19 @@ def stage_create(
         "--encryption",
         help="Type of encryption supported for all files stored on the stage.",
     ),
+    enable_directory: bool = typer.Option(
+        False,
+        "--enable-directory",
+        help="Specifies whether directory support is enabled for the stage.",
+    ),
     **options,
 ) -> CommandResult:
     """
     Creates a named stage if it does not already exist.
     """
-    cursor = StageManager().create(fqn=stage_name, encryption=encryption)
+    cursor = StageManager().create(
+        fqn=stage_name, encryption=encryption, enable_directory=enable_directory
+    )
     return SingleQueryResult(cursor)
 
 
@@ -206,7 +218,7 @@ def stage_diff(
         local_root=Path(folder_name),
         stage_path=StageManager.stage_path_parts_from_str(stage_name),  # noqa: SLF001
     )
-    if get_cli_context().output_format == OutputFormat.JSON:
+    if get_cli_context().output_format.is_json:
         return ObjectResult(diff.to_dict())
     else:
         print_diff_to_console(diff)
@@ -264,6 +276,7 @@ def _put(
     parallel: int,
     overwrite: bool,
     auto_compress: bool,
+    refresh: bool,
 ):
     if recursive and not source_path.is_file():
         cursor_generator = StageManager().put_recursive(
@@ -273,7 +286,7 @@ def _put(
             parallel=parallel,
             auto_compress=auto_compress,
         )
-        return CollectionResult(cursor_generator)
+        output = CollectionResult(cursor_generator)
     else:
         cursor = StageManager().put(
             local_path=source_path.resolve(),
@@ -282,4 +295,10 @@ def _put(
             parallel=parallel,
             auto_compress=auto_compress,
         )
-        return QueryResult(cursor)
+        output = QueryResult(cursor)
+
+    if refresh:
+        StageManager().refresh(
+            StageManager.stage_path_parts_from_str(destination_path).stage_name
+        )
+    return output