snowflake-cli 3.1.0__py3-none-any.whl → 3.2.1__py3-none-any.whl

snowflake/cli/api/metrics.py

@@ -11,8 +11,25 @@
 # 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 Dict, Optional
+import time
+import uuid
+from contextlib import contextmanager
+from dataclasses import dataclass, field, replace
+from heapq import nsmallest
+from typing import ClassVar, Dict, Iterator, List, Optional, Set
+
+
+class CLIMetricsInvalidUsageError(RuntimeError):
+    """
+    Indicative of bug in the code where a call to CLIMetrics was made erroneously
+
+    We do not want metrics errors to break the execution of commands,
+    so only raise this error in the event that an invariant was broken during setup
+    """
+
+    pass
 
 
 class _TypePrefix:
@@ -52,20 +69,135 @@ class CLICounterField:
         f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.post_deploy_scripts"
     )
     PACKAGE_SCRIPTS = f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.package_scripts"
+    EVENT_SHARING = f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.event_sharing"
+    EVENT_SHARING_WARNING = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.event_sharing_warning"
+    )
+    EVENT_SHARING_ERROR = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.event_sharing_error"
+    )
+
+
+@dataclass
+class CLIMetricsSpan:
+    """
+    class for holding metrics span data and encapsulating related operations
+    """
+
+    # keys for dict representation
+    ID_KEY: ClassVar[str] = "id"
+    NAME_KEY: ClassVar[str] = "name"
+    PARENT_KEY: ClassVar[str] = "parent"
+    PARENT_ID_KEY: ClassVar[str] = "parent_id"
+    START_TIME_KEY: ClassVar[str] = "start_time"
+    EXECUTION_TIME_KEY: ClassVar[str] = "execution_time"
+    ERROR_KEY: ClassVar[str] = "error"
+    # total number of spans started under this span, inclusive of itself and its children's children (recursively)
+    SPAN_COUNT_IN_SUBTREE_KEY: ClassVar[str] = "span_count_in_subtree"
+    # the number of spans in the path between the current span and the topmost parent span, inclusive of both
+    SPAN_DEPTH_KEY: ClassVar[str] = "span_depth"
+    # denotes whether direct children were trimmed from telemetry payload
+    TRIMMED_KEY: ClassVar[str] = "trimmed"
+
+    # constructor vars
+    name: str
+    start_time: float  # relative to when the command first started executing
+    parent: Optional[CLIMetricsSpan] = None
+
+    # vars for reporting
+    span_id: str = field(init=False, default_factory=lambda: uuid.uuid4().hex)
+    execution_time: Optional[float] = field(init=False, default=None)
+    error: Optional[BaseException] = field(init=False, default=None)
+    span_depth: int = field(init=False, default=1)
+    span_count_in_subtree: int = field(init=False, default=1)
+
+    # vars for postprocessing
+    # spans started directly under this one
+    children: Set[CLIMetricsSpan] = field(init=False, default_factory=set)
+
+    # private state
+    # start time of the step from the monotonic clock in order to calculate execution time
+    _monotonic_start: float = field(
+        init=False, default_factory=lambda: time.monotonic()
+    )
+
+    def __hash__(self) -> int:
+        return hash(self.span_id)
+
+    def __post_init__(self):
+        if not self.name:
+            raise CLIMetricsInvalidUsageError("span name must not be empty")
+
+        if self.parent:
+            self.parent.add_child(self)
+            self.span_depth = self.parent.span_depth + 1
+
+    def increment_subtree_node_count(self) -> None:
+        self.span_count_in_subtree += 1
+
+        if self.parent:
+            self.parent.increment_subtree_node_count()
+
+    def add_child(self, child: CLIMetricsSpan) -> None:
+        self.children.add(child)
+        self.increment_subtree_node_count()
+
+    def finish(self, error: Optional[BaseException] = None) -> None:
+        """
+        Sets the execution time and (optionally) error raised for the span
+
+        If already called, this method is a no-op
+        """
+        if self.execution_time is not None:
+            return
+
+        if error:
+            self.error = error
 
+        self.execution_time = time.monotonic() - self._monotonic_start
 
+    def to_dict(self) -> Dict:
+        """
+        Custom dict conversion function to be used for reporting telemetry
+        """
+
+        return {
+            self.ID_KEY: self.span_id,
+            self.NAME_KEY: self.name,
+            self.START_TIME_KEY: self.start_time,
+            self.PARENT_KEY: self.parent.name if self.parent is not None else None,
+            self.PARENT_ID_KEY: (
+                self.parent.span_id if self.parent is not None else None
+            ),
+            self.EXECUTION_TIME_KEY: self.execution_time,
+            self.ERROR_KEY: type(self.error).__name__ if self.error else None,
+            self.SPAN_COUNT_IN_SUBTREE_KEY: self.span_count_in_subtree,
+            self.SPAN_DEPTH_KEY: self.span_depth,
+        }
+
+
+@dataclass
 class CLIMetrics:
     """
     Class to track various metrics across the execution of a command
     """
 
-    def __init__(self):
-        self._counters: Dict[str, int] = {}
+    # limits for reporting purposes
+    SPAN_DEPTH_LIMIT: ClassVar[int] = 5
+    SPAN_TOTAL_LIMIT: ClassVar[int] = 100
+
+    _counters: Dict[str, int] = field(init=False, default_factory=dict)
+    # stack of in progress spans as command is executing
+    _in_progress_spans: List[CLIMetricsSpan] = field(init=False, default_factory=list)
+    # list of finished steps for telemetry to process
+    _completed_spans: List[CLIMetricsSpan] = field(init=False, default_factory=list)
+    # monotonic clock time of when this class was initialized to approximate when the command first started executing
+    _monotonic_start: float = field(
+        init=False, default_factory=lambda: time.monotonic(), compare=False
+    )
 
-    def __eq__(self, other):
-        if isinstance(other, CLIMetrics):
-            return self._counters == other._counters
-        return False
+    def clone(self) -> CLIMetrics:
+        return replace(self)
 
     def get_counter(self, name: str) -> Optional[int]:
         return self._counters.get(name)
@@ -86,7 +218,91 @@ class CLIMetrics:
         else:
             self._counters[name] += value
 
+    @property
+    def current_span(self) -> Optional[CLIMetricsSpan]:
+        return self._in_progress_spans[-1] if len(self._in_progress_spans) > 0 else None
+
+    @contextmanager
+    def start_span(self, name: str) -> Iterator[CLIMetricsSpan]:
+        """
+        Starts a new span that tracks various metrics throughout its execution
+
+        Assumes that parent spans contain the entirety of their child spans
+        If not provided, parent spans are automatically populated as the most recently executed spans
+
+        Spans are not emitted in telemetry if depth/total limits are exceeded
+
+        :raises CliMetricsInvalidUsageError: if the step name is empty
+        """
+        new_span = CLIMetricsSpan(
+            name=name,
+            start_time=time.monotonic() - self._monotonic_start,
+            parent=self.current_span,
+        )
+
+        self._in_progress_spans.append(new_span)
+
+        try:
+            yield new_span
+        except BaseException as err:
+            new_span.finish(error=err)
+            raise
+        else:
+            new_span.finish()
+        finally:
+            self._completed_spans.append(new_span)
+            self._in_progress_spans.remove(new_span)
+
     @property
     def counters(self) -> Dict[str, int]:
         # return a copy of the original dict to avoid mutating the original
         return self._counters.copy()
+
+    @property
+    def num_spans_past_depth_limit(self) -> int:
+        return len(
+            [
+                span
+                for span in self._completed_spans
+                if span.span_depth > self.SPAN_DEPTH_LIMIT
+            ]
+        )
+
+    @property
+    def num_spans_past_total_limit(self) -> int:
+        return max(0, len(self._completed_spans) - self.SPAN_TOTAL_LIMIT)
+
+    @property
+    def completed_spans(self) -> List[Dict]:
+        """
+        Returns the completed spans tracked throughout a command, sorted by start time, for reporting telemetry
+
+        Ensures that the spans we send are within the configured limits and marks
+        certain spans as trimmed if their children would bypass the limits we set
+        """
+        # take spans breadth-first within the depth and total limits
+        # since we care more about the big picture than granularity
+        spans_to_report = set(
+            nsmallest(
+                n=self.SPAN_TOTAL_LIMIT,
+                iterable=(
+                    span
+                    for span in self._completed_spans
+                    if span.span_depth <= self.SPAN_DEPTH_LIMIT
+                ),
+                key=lambda span: (span.span_depth, span.start_time),
+            )
+        )
+
+        # sort by start time to make reading the payload easier
+        sorted_spans_to_report = sorted(
+            spans_to_report, key=lambda span: span.start_time
+        )
+
+        return [
+            {
+                **span.to_dict(),
+                CLIMetricsSpan.TRIMMED_KEY: not span.children <= spans_to_report,
+            }
+            for span in sorted_spans_to_report
+        ]

snowflake/cli/api/output/types.py

@@ -37,7 +37,7 @@ class ObjectResult(CommandResult):
 
 
 class CollectionResult(CommandResult):
-    def __init__(self, elements: t.Iterable[t.Dict]):
+    def __init__(self, elements: t.Iterable[t.Dict] | t.Generator[t.Dict, None, None]):
         self._elements = elements
 
     @property

snowflake/cli/api/project/definition_conversion.py

@@ -1,13 +1,21 @@
 from __future__ import annotations
 
 import logging
+import shutil
+import tempfile
+from copy import deepcopy
 from pathlib import Path
 from tempfile import TemporaryDirectory, mkstemp
 from typing import Any, Dict, Literal, Optional
 
 from click import ClickException
 from snowflake.cli._plugins.nativeapp.artifacts import (
-    BundleMap,
+    bundle_artifacts,
+)
+from snowflake.cli._plugins.nativeapp.bundle_context import BundleContext
+from snowflake.cli._plugins.nativeapp.codegen.compiler import TEMPLATES_PROCESSOR
+from snowflake.cli._plugins.nativeapp.codegen.templates.templates_processor import (
+    TemplatesProcessor,
 )
 from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntityModel,
@@ -46,6 +54,7 @@ from snowflake.cli.api.project.schemas.v1.snowpark.snowpark import Snowpark
 from snowflake.cli.api.project.schemas.v1.streamlit.streamlit import Streamlit
 from snowflake.cli.api.rendering.jinja import get_basic_jinja_env
 from snowflake.cli.api.utils.definition_rendering import render_definition_template
+from snowflake.cli.api.utils.dict_utils import deep_merge_dicts
 
 log = logging.getLogger(__name__)
 
@@ -107,12 +116,10 @@ def convert_project_definition_to_v2(
         if definition_v1.streamlit
         else {}
     )
-    native_app_data = (
-        convert_native_app_to_v2_data(
-            project_root, definition_v1.native_app, template_context
-        )
+    native_app_data, native_app_template_context = (
+        convert_native_app_to_v2_data(definition_v1.native_app, template_context)
         if definition_v1.native_app
-        else {}
+        else ({}, {})
     )
     envs = convert_envs_to_v2(definition_v1)
 
@@ -137,7 +144,16 @@ def convert_project_definition_to_v2(
 
     # If the user's files have any template tags in them, they
     # also need to be migrated to point to the v2 entities
-    _convert_templates_in_files(project_root, definition_v1, definition_v2, in_memory)
+    replacement_template_context = deepcopy(template_context) or {}
+    deep_merge_dicts(replacement_template_context, native_app_template_context)
+    if replacement_template_context:
+        _convert_templates_in_files(
+            project_root,
+            definition_v1,
+            definition_v2,
+            in_memory,
+            replacement_template_context,
+        )
 
     return definition_v2
 
@@ -243,10 +259,9 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
 
 
 def convert_native_app_to_v2_data(
-    project_root: Path,
     native_app: NativeApp,
     template_context: Optional[Dict[str, Any]] = None,
-) -> Dict[str, Any]:
+) -> tuple[dict[str, Any], dict[str, Any]]:
     def _make_meta(obj: Application | Package):
         meta = {}
         if obj.role:
@@ -257,39 +272,6 @@ def convert_native_app_to_v2_data(
             meta["post_deploy"] = obj.post_deploy
         return meta
 
-    def _find_manifest():
-        # We don't know which file in the project directory is the actual manifest,
-        # and we can't iterate through the artifacts property since the src can contain
-        # glob patterns. The simplest solution is to bundle the app and find the
-        # manifest file from the resultant BundleMap, since the bundle process ensures
-        # that only a single source path can map to the corresponding destination path
-        bundle_map = BundleMap(
-            project_root=project_root, deploy_root=project_root / native_app.deploy_root
-        )
-        for artifact in native_app.artifacts:
-            bundle_map.add(artifact)
-
-        manifest_path = next(
-            (
-                src
-                for src, dest in bundle_map.all_mappings(
-                    absolute=True, expand_directories=True
-                )
-                if dest.name == "manifest.yml"
-            ),
-            None,
-        )
-        if not manifest_path:
-            # The manifest field is required, so we can't gracefully handle it being missing
-            raise ClickException(
-                "manifest.yml file not found in any Native App artifact sources, "
-                "unable to perform migration"
-            )
-
-        # Use a POSIX path to be consistent with other migrated fields
-        # which use POSIX paths as default values
-        return manifest_path.relative_to(project_root).as_posix()
-
     package_entity_name = "pkg"
     if (
         native_app.package
@@ -305,7 +287,6 @@ def convert_native_app_to_v2_data(
     package = {
         "type": "application package",
         "identifier": package_identifier,
-        "manifest": _find_manifest(),
         "artifacts": native_app.artifacts,
     }
 
@@ -360,12 +341,63 @@ def convert_native_app_to_v2_data(
         ):
             app["debug"] = native_app.application.debug
 
-    return {
+    pdfv2_yml = {
         "entities": {
             package_entity_name: package,
             app_entity_name: app,
         }
     }
+    template_replacements = {
+        "ctx": {
+            "native_app": {
+                "name": native_app.name,  # This is a literal since there's no equivalent in v2
+                # omitting "artifacts" since lists are not supported in templates
+                "bundle_root": _make_template(
+                    f"ctx.entities.{package_entity_name}.bundle_root"
+                ),
+                "deploy_root": _make_template(
+                    f"ctx.entities.{package_entity_name}.deploy_root"
+                ),
+                "generated_root": _make_template(
+                    f"ctx.entities.{package_entity_name}.generated_root"
+                ),
+                "source_stage": _make_template(
+                    f"ctx.entities.{package_entity_name}.stage"
+                ),
+                "scratch_stage": _make_template(
+                    f"ctx.entities.{package_entity_name}.scratch_stage"
+                ),
+                "package": {
+                    # omitting "scripts" since lists are not supported in templates
+                    "role": _make_template(
+                        f"ctx.entities.{package_entity_name}.meta.role"
+                    ),
+                    "name": _make_template(
+                        f"ctx.entities.{package_entity_name}.identifier"
+                    ),
+                    "warehouse": _make_template(
+                        f"ctx.entities.{package_entity_name}.meta.warehouse"
+                    ),
+                    "distribution": _make_template(
+                        f"ctx.entities.{package_entity_name}.distribution"
+                    ),
+                    # omitting "post_deploy" since lists are not supported in templates
+                },
+                "application": {
+                    "role": _make_template(f"ctx.entities.{app_entity_name}.meta.role"),
+                    "name": _make_template(
+                        f"ctx.entities.{app_entity_name}.identifier"
+                    ),
+                    "warehouse": _make_template(
+                        f"ctx.entities.{app_entity_name}.meta.warehouse"
+                    ),
+                    "debug": _make_template(f"ctx.entities.{app_entity_name}.debug"),
+                    # omitting "post_deploy" since lists are not supported in templates
+                },
+            }
+        }
+    }
+    return pdfv2_yml, template_replacements
 
 
 def convert_envs_to_v2(pd: ProjectDefinition):
@@ -380,33 +412,106 @@ def _convert_templates_in_files(
     definition_v1: ProjectDefinition,
     definition_v2: ProjectDefinitionV2,
     in_memory: bool,
+    replacement_template_context: dict[str, Any],
 ):
     """Converts templates in other files to the new format"""
-    # TODO handle artifacts using the "templates" processor
-    # For now this only handles Native App package scripts
+    # Set up fakers so that references to ctx.env. and fn.
+    # get templated to the same literal, since those references
+    # are the same in v1 and v2
+    replacement_template_context["ctx"]["env"] = _EnvFaker()
+    replacement_template_context["fn"] = _FnFaker()
+
     metrics = get_cli_context().metrics
-    metrics.set_counter_default(CLICounterField.PACKAGE_SCRIPTS, 0)
 
-    if (na := definition_v1.native_app) and (pkg := na.package) and pkg.scripts:
-        metrics.set_counter(CLICounterField.PACKAGE_SCRIPTS, 1)
-        cli_console.warning(
-            "WARNING: native_app.package.scripts is deprecated. Please migrate to using native_app.package.post_deploy."
-        )
-        # If the v1 definition has a Native App with a package, we know
+    if na := definition_v1.native_app:
+        # If the v1 definition has a Native App, we know
         # that the v2 definition will have exactly one application package entity
-        pkg_entity: ApplicationPackageEntityModel = list(
+        pkg_model: ApplicationPackageEntityModel = list(
             definition_v2.get_entities_by_type(
                 ApplicationPackageEntityModel.get_type()
             ).values()
         )[0]
-        converted_post_deploy_hooks = _convert_package_script_files(
-            project_root, pkg.scripts, pkg_entity, in_memory
-        )
-        if pkg_entity.meta is None:
-            pkg_entity.meta = MetaField()
-        if pkg_entity.meta.post_deploy is None:
-            pkg_entity.meta.post_deploy = []
-        pkg_entity.meta.post_deploy += converted_post_deploy_hooks
+
+        # Convert templates in artifacts by passing them through the TemplatesProcessor
+        # but providing a context that maps v1 template references to the equivalent v2
+        # references instead of resolving to literals
+        # For example, replacement_template_context might look like
+        # {
+        #     "ctx": {
+        #         "native_app": {
+        #             "bundle_root": "<% ctx.entities.pkg.bundle_root %>",
+        #             "deploy_root": "<% ctx.entities.pkg.deploy_root %>",
+        #             "application": {
+        #                 "name": "<% ctx.entities.app.identifier %>",
+        #             }
+        #             and so on...
+        #          }
+        #     }
+        # }
+        # We only convert files on-disk if the "templates" processor is used in the artifacts
+        # and if we're doing a permanent conversion. If we're doing an in-memory conversion,
+        # the CLI global template context is already populated with the v1 definition, so
+        # we don't want to convert the v1 template references in artifact files
+        metrics.set_counter_default(CLICounterField.TEMPLATES_PROCESSOR, 0)
+        artifacts_to_template = [
+            artifact
+            for artifact in pkg_model.artifacts
+            for processor in artifact.processors
+            if processor.name == TEMPLATES_PROCESSOR
+        ]
+        if not in_memory and artifacts_to_template:
+            metrics.set_counter(CLICounterField.TEMPLATES_PROCESSOR, 1)
+
+            # Create a temporary directory to hold the expanded templates,
+            # as if a bundle step had been run but without affecting any
+            # files on disk outside of the artifacts we want to convert
+            with tempfile.TemporaryDirectory() as d:
+                deploy_root = Path(d)
+                bundle_ctx = BundleContext(
+                    package_name=pkg_model.identifier,
+                    artifacts=pkg_model.artifacts,
+                    project_root=project_root,
+                    bundle_root=project_root / pkg_model.bundle_root,
+                    deploy_root=deploy_root,
+                    generated_root=(
+                        project_root / deploy_root / pkg_model.generated_root
+                    ),
+                )
+                template_processor = TemplatesProcessor(bundle_ctx)
+                bundle_map = bundle_artifacts(
+                    project_root, deploy_root, artifacts_to_template
+                )
+                for src, dest in bundle_map.all_mappings(
+                    absolute=True, expand_directories=True
+                ):
+                    if src.is_dir():
+                        continue
+                    # We call the implementation directly instead of calling process()
+                    # since we need access to the BundleMap to copy files anyways
+                    template_processor.expand_templates_in_file(
+                        src, dest, replacement_template_context
+                    )
+                    # Copy the expanded file back to its original source location if it was modified
+                    if not dest.is_symlink():
+                        shutil.copyfile(dest, src)
+
+        # Convert package script files to post-deploy hooks
+        metrics.set_counter_default(CLICounterField.PACKAGE_SCRIPTS, 0)
+        if (pkg := na.package) and pkg.scripts:
+            metrics.set_counter(CLICounterField.PACKAGE_SCRIPTS, 1)
+            cli_console.warning(
+                "WARNING: native_app.package.scripts is deprecated. "
+                "Please migrate to using native_app.package.post_deploy."
+            )
+
+            converted_post_deploy_hooks = _convert_package_script_files(
+                project_root, pkg.scripts, pkg_model, in_memory
+            )
+            if pkg_model.meta is None:
+                pkg_model.meta = MetaField()
+            if pkg_model.meta.post_deploy is None:
+                pkg_model.meta.post_deploy = []
+            pkg_model.meta.post_deploy += converted_post_deploy_hooks
 
 
 def _convert_package_script_files(
@@ -447,6 +552,18 @@ def _convert_package_script_files(
     return post_deploy_hooks
 
 
+class _EnvFaker:
+    def __getitem__(self, item):
+        return _make_template(f"ctx.env.{item}")
+
+
+class _FnFaker:
+    def __getitem__(self, item):
+        return lambda *args: _make_template(
+            f"fn.{item}({', '.join(repr(a) for a in args)})"
+        )
+
+
 def _make_template(template: str) -> str:
     return f"{PROJECT_TEMPLATE_VARIABLE_OPENING} {template} {PROJECT_TEMPLATE_VARIABLE_CLOSING}"
 

snowflake/cli/api/rest_api.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import json
 import logging
 from typing import Any, Dict, Optional
+from urllib.parse import parse_qsl, urlencode, urlparse
 
 from click import ClickException
 from snowflake.cli.api.constants import SF_REST_API_URL_PREFIX
@@ -107,7 +108,9 @@ class RestApi:
         url = f"{SF_REST_API_URL_PREFIX}/databases/{db_name}/schemas/{schema_name}"
         return self._fetch_endpoint_exists(url)
 
-    def determine_url_for_create_query(self, object_type: str) -> str:
+    def determine_url_for_create_query(
+        self, object_type: str, replace: bool = False, if_not_exists: bool = False
+    ) -> str:
         """
         Determine an url for creating an object of given type via REST API.
         If URL cannot be determined, the function throws CannotDetermineCreateURLException exception.
@@ -124,10 +127,16 @@ class RestApi:
         """
         plural_object_type = _pluralize_object_type(object_type)
 
+        query_params = {}
+
+        if replace or if_not_exists:
+            param = "ifNotExists" if if_not_exists else "orReplace"
+            query_params = {"createMode": param}
+
         if self.get_endpoint_exists(
             url := f"{SF_REST_API_URL_PREFIX}/{plural_object_type}/"
         ):
-            return url
+            return self._add_query_parameters_to_url(url, query_params)
 
         db = self.conn.database
         if not db:
@@ -139,7 +148,7 @@ class RestApi:
         if self.get_endpoint_exists(
             url := f"{SF_REST_API_URL_PREFIX}/databases/{db}/{plural_object_type}/"
         ):
-            return url
+            return self._add_query_parameters_to_url(url, query_params)
 
         schema = self.conn.schema
         if not schema:
@@ -151,12 +160,25 @@ class RestApi:
         if self.get_endpoint_exists(
             url := f"{SF_REST_API_URL_PREFIX}/databases/{self.conn.database}/schemas/{self.conn.schema}/{plural_object_type}/"
         ):
-            return url
+            return self._add_query_parameters_to_url(url, query_params)
 
         raise CannotDetermineCreateURLException(
             f"Create operation for type {object_type} is not supported. Try using `sql -q 'CREATE ...'` command."
         )
 
+    @staticmethod
+    def _add_query_parameters_to_url(url: str, query_params: Dict[str, Any]) -> str:
+        """
+        Updates existing url with new query parameters.
+        They should be passed as key-value pairs in query_params dict.
+        """
+        if not query_params:
+            return url
+        url_parts = urlparse(url)
+        query = dict(parse_qsl(url_parts.query))
+        query.update(query_params)
+        return url_parts._replace(query=urlencode(query)).geturl()
+
 
 class DatabaseNotDefinedException(ClickException):
     pass

snowflake/cli/api/secure_utils.py

@@ -108,7 +108,7 @@ def _windows_restrict_file_permissions(path: Path) -> None:
 
     for user in windows_get_not_whitelisted_users_with_access(path):
         log.info("Removing permissions of user %s from file %s", user, path)
-        subprocess.run(["icacls", str(path), "/DENY", f"{user}:F"])
+        subprocess.run(["icacls", str(path), "/remove:g", f"{user}"])
 
 
 def restrict_file_permissions(file_path: Path) -> None: