snowflake-cli-labs 2.8.0rc0__py3-none-any.whl → 3.0.0rc0__py3-none-any.whl

snowflake/cli/api/project/schemas/project_definition.py

@@ -15,22 +15,22 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 from packaging.version import Version
 from pydantic import Field, ValidationError, field_validator, model_validator
 from snowflake.cli.api.feature_flags import FeatureFlag
 from snowflake.cli.api.project.errors import SchemaValidationError
-from snowflake.cli.api.project.schemas.entities.application_entity import (
-    ApplicationEntity,
+from snowflake.cli.api.project.schemas.entities.application_entity_model import (
+    ApplicationEntityModel,
 )
 from snowflake.cli.api.project.schemas.entities.common import (
     DefaultsField,
     TargetField,
 )
 from snowflake.cli.api.project.schemas.entities.entities import (
-    Entity,
-    v2_entity_types_map,
+    EntityModel,
+    v2_entity_model_types_map,
 )
 from snowflake.cli.api.project.schemas.native_app.native_app import (
     NativeApp,
@@ -42,6 +42,8 @@ from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 from snowflake.cli.api.utils.types import Context
 from typing_extensions import Annotated
 
+AnnotatedEntity = Annotated[EntityModel, Field(discriminator="type")]
+
 
 @dataclass
 class ProjectProperties:
@@ -111,9 +113,7 @@ class DefinitionV11(DefinitionV10):
 
 
 class DefinitionV20(_ProjectDefinitionBase):
-    entities: Dict[str, Annotated[Entity, Field(discriminator="type")]] = Field(
-        title="Entity definitions."
-    )
+    entities: Dict[str, AnnotatedEntity] = Field(title="Entity definitions.")
 
     @model_validator(mode="before")
     @classmethod
@@ -123,34 +123,52 @@ class DefinitionV20(_ProjectDefinitionBase):
         """
         if "defaults" in data and "entities" in data:
             for key, entity in data["entities"].items():
-                entity_type = entity["type"]
-                if entity_type not in v2_entity_types_map:
+                entity_fields = get_allowed_fields_for_entity(entity)
+                if not entity_fields:
                     continue
-                entity_model = v2_entity_types_map[entity_type]
                 for default_key, default_value in data["defaults"].items():
-                    if (
-                        default_key in entity_model.model_fields
-                        and default_key not in entity
-                    ):
+                    if default_key in entity_fields and default_key not in entity:
                         entity[default_key] = default_value
         return data
 
     @field_validator("entities", mode="after")
     @classmethod
-    def validate_entities(cls, entities: Dict[str, Entity]) -> Dict[str, Entity]:
+    def validate_entities_identifiers(
+        cls, entities: Dict[str, EntityModel]
+    ) -> Dict[str, EntityModel]:
+        for key, entity in entities.items():
+            entity.set_entity_id(key)
+            entity.validate_identifier()
+        return entities
+
+    @field_validator("entities", mode="after")
+    @classmethod
+    def validate_entities(
+        cls, entities: Dict[str, AnnotatedEntity]
+    ) -> Dict[str, AnnotatedEntity]:
         for key, entity in entities.items():
             # TODO Automatically detect TargetFields to validate
-            if entity.type == ApplicationEntity.get_type():
-                if isinstance(entity.from_, TargetField):
-                    target_key = entity.from_.target
-                    target_object = entity.from_
-                    target_type = target_object.get_type()
-                    cls._validate_target_field(target_key, target_type, entities)
+            if isinstance(entity, list):
+                for e in entity:
+                    cls._validate_single_entity(e, entities)
+            else:
+                cls._validate_single_entity(entity, entities)
         return entities
 
+    @classmethod
+    def _validate_single_entity(
+        cls, entity: EntityModel, entities: Dict[str, AnnotatedEntity]
+    ):
+        if entity.type == ApplicationEntityModel.get_type():
+            if isinstance(entity.from_, TargetField):
+                target_key = entity.from_.target
+                target_object = entity.from_
+                target_type = target_object.get_type()
+                cls._validate_target_field(target_key, target_type, entities)
+
     @classmethod
     def _validate_target_field(
-        cls, target_key: str, target_type: Entity, entities: Dict[str, Entity]
+        cls, target_key: str, target_type: EntityModel, entities: Dict[str, EntityModel]
     ):
         if target_key not in entities:
             raise ValueError(f"No such target: {target_key}")
@@ -172,6 +190,39 @@ class DefinitionV20(_ProjectDefinitionBase):
         default=None,
     )
 
+    mixins: Optional[Dict[str, Dict]] = Field(
+        title="Mixins to apply to entities",
+        default=None,
+    )
+
+    @model_validator(mode="before")
+    @classmethod
+    def apply_mixins(cls, data: Dict) -> Dict:
+        """
+        Applies mixins to those entities, whose meta field contains the mixin name.
+        """
+        if "mixins" not in data or "entities" not in data:
+            return data
+
+        for entity in data["entities"].values():
+            entity_mixins = entity_mixins_to_list(
+                entity.get("meta", {}).get("use_mixins")
+            )
+
+            entity_fields = get_allowed_fields_for_entity(entity)
+            if entity_fields and entity_mixins:
+                for mixin_name in entity_mixins:
+                    if mixin_name in data["mixins"]:
+                        for key, value in data["mixins"][mixin_name].items():
+                            if key in entity_fields:
+                                entity[key] = value
+                    else:
+                        raise ValueError(f"Mixin {mixin_name} not found in mixins")
+        return data
+
+    def get_entities_by_type(self, entity_type: str):
+        return {i: e for i, e in self.entities.items() if e.get_type() == entity_type}
+
 
 def build_project_definition(**data) -> ProjectDefinition:
     """
@@ -197,3 +248,26 @@ def get_version_map():
     if FeatureFlag.ENABLE_PROJECT_DEFINITION_V2.is_enabled():
         version_map["2"] = DefinitionV20
     return version_map
+
+
+def entity_mixins_to_list(entity_mixins: Optional[str | List[str]]) -> List[str]:
+    """
+    Convert an optional string or a list of strings to a list of strings.
+    """
+    if entity_mixins is None:
+        return []
+    if isinstance(entity_mixins, str):
+        return [entity_mixins]
+    return entity_mixins
+
+
+def get_allowed_fields_for_entity(entity: Dict[str, Any]) -> List[str]:
+    """
+    Get the allowed fields for the given entity.
+    """
+    entity_type = entity.get("type")
+    if entity_type not in v2_entity_model_types_map:
+        return []
+
+    entity_model = v2_entity_model_types_map[entity_type]
+    return entity_model.model_fields

snowflake/cli/api/project/schemas/updatable_model.py

@@ -117,6 +117,7 @@ class UpdatableModel(BaseModel):
         # all the values of the class attributes. We go in reverse order so that
         # values in subclasses overrides values from parent classes in case of field overrides.
 
+        private_attrs = set()
         for class_ in reversed(cls.__mro__):
             class_dict = class_.__dict__
             field_annotations.update(class_dict.get("__annotations__", {}))
@@ -128,10 +129,15 @@ class UpdatableModel(BaseModel):
             else:
                 # If Pydantic did not process this class yet, get the values from class_dict directly
                 field_values.update(class_dict)
+            for pa in class_dict.get("__private_attributes__", []):
+                private_attrs.add(pa)
 
         # Add Pydantic validation wrapper around all fields except `DiscriminatorField`s
         for field_name in field_annotations:
-            if not cls._is_entity_type_field(field_values.get(field_name)):
+            if field_name in private_attrs:
+                continue
+            field = field_values.get(field_name)
+            if not cls._is_entity_type_field(field):
                 cls._add_validator(field_name)
 
     @classmethod
@@ -154,7 +160,8 @@ class UpdatableModel(BaseModel):
 
         setattr(
             cls,
-            f"_field_validator_with_verbose_name_to_avoid_name_conflict_{field_name}",
+            # Unique name so that subclasses get a unique instance of this validator
+            f"_{cls.__module__}.{cls.__name__}_validate_{field_name}",
             field_validator(field_name, mode="wrap")(validator_skipping_templated_str),
         )
 
@@ -187,7 +194,8 @@ def DiscriminatorField(*args, **kwargs):  # noqa N802
     When this `DiscriminatorField` is used on a pydantic attribute,
     we will not allow templating on it.
     """
-    return Field(is_discriminator_field=True, *args, **kwargs)
+    extra = dict(is_discriminator_field=True)
+    return Field(json_schema_extra=extra, *args, **kwargs)
 
 
 def IdentifierField(*args, **kwargs):  # noqa N802

snowflake/cli/api/project/util.py

@@ -34,6 +34,9 @@ UNQUOTED_IDENTIFIER_REGEX = r"([a-zA-Z_])([a-zA-Z0-9_$]{0,254})"
 QUOTED_IDENTIFIER_REGEX = r'"((""|[^"]){0,255})"'
 VALID_IDENTIFIER_REGEX = f"(?:{UNQUOTED_IDENTIFIER_REGEX}|{QUOTED_IDENTIFIER_REGEX})"
 
+# An env var that is used to suffix the names of some account-level resources
+TEST_RESOURCE_SUFFIX_VAR = "SNOWFLAKE_CLI_TEST_RESOURCE_SUFFIX"
+
 
 def encode_uri_component(s: str) -> str:
     """
@@ -191,12 +194,6 @@ def extract_schema(qualified_name: str):
     return None
 
 
-def generate_user_env(username: str) -> dict:
-    return {
-        "USER": username,
-    }
-
-
 def first_set_env(*keys: str):
     for k in keys:
         v = os.getenv(k)
@@ -259,3 +256,23 @@ def identifier_to_show_like_pattern(identifier: str) -> str:
     matching this identifier
     """
     return f"'{escape_like_pattern(unquote_identifier(identifier))}'"
+
+
+def append_test_resource_suffix(identifier: str) -> str:
+    """
+    Append a suffix that should be added to specified account-level resources.
+
+    This is an internal concern that is currently only used in tests
+    to isolate concurrent runs and to add the test name to resources.
+    """
+    suffix = os.environ.get(TEST_RESOURCE_SUFFIX_VAR, "")
+    if identifier_to_str(identifier).endswith(identifier_to_str(suffix)):
+        # If the suffix has already been added, don't add it again
+        return identifier
+    if is_valid_quoted_identifier(identifier) or is_valid_quoted_identifier(suffix):
+        # If either identifier is already quoted, use concat_identifier
+        # to add the suffix inside the quotes
+        return concat_identifiers([identifier, suffix])
+    # Otherwise just append the string, don't add quotes
+    # in case the user doesn't want them
+    return f"{identifier}{suffix}"

snowflake/cli/api/rendering/jinja.py

@@ -17,7 +17,7 @@ from __future__ import annotations
 
 from pathlib import Path
 from textwrap import dedent
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 import jinja2
 from jinja2 import Environment, StrictUndefined, loaders
@@ -82,8 +82,32 @@ class IgnoreAttrEnvironment(Environment):
             return self.undefined(obj=obj, name=argument)
 
 
+def _get_jinja_env(loader: Optional[loaders.BaseLoader] = None) -> Environment:
+    return env_bootstrap(
+        IgnoreAttrEnvironment(
+            loader=loader or loaders.BaseLoader(),
+            keep_trailing_newline=True,
+            undefined=StrictUndefined,
+        )
+    )
+
+
+def jinja_render_from_str(template_content: str, data: Dict[str, Any]) -> str:
+    """
+    Renders a jinja template and outputs either the rendered contents as string or writes to a file.
+
+    Args:
+        template_content (str): template contents
+        data (dict): A dictionary of jinja variables and their actual values
+
+    Returns:
+        None if file path is provided, else returns the rendered string.
+    """
+    return _get_jinja_env().from_string(template_content).render(data)
+
+
 def jinja_render_from_file(
-    template_path: Path, data: Dict, output_file_path: Optional[Path] = None
+    template_path: Path, data: Dict[str, Any], output_file_path: Optional[Path] = None
 ) -> Optional[str]:
     """
     Renders a jinja template and outputs either the rendered contents as string or writes to a file.
@@ -96,12 +120,8 @@ def jinja_render_from_file(
     Returns:
         None if file path is provided, else returns the rendered string.
     """
-    env = env_bootstrap(
-        IgnoreAttrEnvironment(
-            loader=loaders.FileSystemLoader(template_path.parent),
-            keep_trailing_newline=True,
-            undefined=StrictUndefined,
-        )
+    env = _get_jinja_env(
+        loader=loaders.FileSystemLoader(template_path.parent.as_posix())
     )
     loaded_template = env.get_template(template_path.name)
     rendered_result = loaded_template.render(**data)

snowflake/cli/api/rendering/sql_templates.py

@@ -14,11 +14,13 @@
 
 from __future__ import annotations
 
-from typing import Dict, Optional
+from typing import Dict
 
 from click import ClickException
-from jinja2 import StrictUndefined, loaders
-from snowflake.cli.api.cli_global_context import cli_context
+from jinja2 import Environment, StrictUndefined, loaders, meta
+from snowflake.cli.api.cli_global_context import get_cli_context
+from snowflake.cli.api.console.console import cli_console
+from snowflake.cli.api.exceptions import InvalidTemplate
 from snowflake.cli.api.rendering.jinja import (
     CONTEXT_KEY,
     FUNCTION_KEY,
@@ -26,26 +28,52 @@ from snowflake.cli.api.rendering.jinja import (
     env_bootstrap,
 )
 
-_SQL_TEMPLATE_START = "&{"
-_SQL_TEMPLATE_END = "}"
+_SQL_TEMPLATE_START = "<%"
+_SQL_TEMPLATE_END = "%>"
+_OLD_SQL_TEMPLATE_START = "&{"
+_OLD_SQL_TEMPLATE_END = "}"
 RESERVED_KEYS = [CONTEXT_KEY, FUNCTION_KEY]
 
 
-def get_sql_cli_jinja_env(*, loader: Optional[loaders.BaseLoader] = None):
+def _get_sql_jinja_env(template_start: str, template_end: str) -> Environment:
     _random_block = "___very___unique___block___to___disable___logic___blocks___"
     return env_bootstrap(
         IgnoreAttrEnvironment(
-            loader=loader or loaders.BaseLoader(),
-            keep_trailing_newline=True,
-            variable_start_string=_SQL_TEMPLATE_START,
-            variable_end_string=_SQL_TEMPLATE_END,
+            variable_start_string=template_start,
+            variable_end_string=template_end,
+            loader=loaders.BaseLoader(),
             block_start_string=_random_block,
             block_end_string=_random_block,
+            keep_trailing_newline=True,
             undefined=StrictUndefined,
         )
     )
 
 
+def _does_template_have_env_syntax(env: Environment, template_content: str) -> bool:
+    template = env.parse(template_content)
+    return bool(meta.find_undeclared_variables(template))
+
+
+def choose_sql_jinja_env_based_on_template_syntax(template_content: str) -> Environment:
+    old_syntax_env = _get_sql_jinja_env(_OLD_SQL_TEMPLATE_START, _OLD_SQL_TEMPLATE_END)
+    new_syntax_env = _get_sql_jinja_env(_SQL_TEMPLATE_START, _SQL_TEMPLATE_END)
+    has_old_syntax = _does_template_have_env_syntax(old_syntax_env, template_content)
+    has_new_syntax = _does_template_have_env_syntax(new_syntax_env, template_content)
+    if has_old_syntax and has_new_syntax:
+        raise InvalidTemplate(
+            f"The SQL query mixes {_OLD_SQL_TEMPLATE_START} ... {_OLD_SQL_TEMPLATE_END} syntax"
+            f" and {_SQL_TEMPLATE_START} ... {_SQL_TEMPLATE_END} syntax."
+        )
+    if has_old_syntax:
+        cli_console.warning(
+            f"Warning: {_OLD_SQL_TEMPLATE_START} ... {_OLD_SQL_TEMPLATE_END} syntax is deprecated."
+            f" Use {_SQL_TEMPLATE_START} ... {_SQL_TEMPLATE_END} syntax instead."
+        )
+        return old_syntax_env
+    return new_syntax_env
+
+
 def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
     data = data or {}
 
@@ -55,6 +83,7 @@ def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
                 f"{reserved_key} in user defined data. The `{reserved_key}` variable is reserved for CLI usage."
             )
 
-    context_data = cli_context.template_context
+    context_data = get_cli_context().template_context
     context_data.update(data)
-    return get_sql_cli_jinja_env().from_string(content).render(**context_data)
+    env = choose_sql_jinja_env_based_on_template_syntax(content)
+    return env.from_string(content).render(context_data)

snowflake/cli/api/secure_path.py

@@ -349,6 +349,9 @@ class SecurePath:
         ):
             raise FileTooLargeError(self._path.resolve(), size_limit_in_mb)
 
+    def rename(self, new_name: Union[str | Path]):
+        self._path.rename(new_name)
+
 
 def _raise_file_exists_error(path: Path):
     raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), path)

snowflake/cli/api/sql_execution.py

@@ -21,7 +21,7 @@ from io import StringIO
 from textwrap import dedent
 from typing import Iterable, Optional, Tuple
 
-from snowflake.cli.api.cli_global_context import cli_context
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console
 from snowflake.cli.api.constants import ObjectType
 from snowflake.cli.api.exceptions import (
@@ -35,27 +35,21 @@ from snowflake.cli.api.project.util import (
     unquote_identifier,
 )
 from snowflake.cli.api.utils.cursor import find_first_row
+from snowflake.connector import SnowflakeConnection
 from snowflake.connector.cursor import DictCursor, SnowflakeCursor
 from snowflake.connector.errors import ProgrammingError
 
 
-class SqlExecutionMixin:
-    def __init__(self):
+class SqlExecutor:
+    def __init__(self, connection: SnowflakeConnection | None = None):
         self._snowpark_session = None
+        self._connection = connection
 
     @property
-    def _conn(self):
-        return cli_context.connection
-
-    @property
-    def snowpark_session(self):
-        if not self._snowpark_session:
-            from snowflake.snowpark.session import Session
-
-            self._snowpark_session = Session.builder.configs(
-                {"connection": self._conn}
-            ).create()
-        return self._snowpark_session
+    def _conn(self) -> SnowflakeConnection:
+        if self._connection:
+            return self._connection
+        return get_cli_context().connection
 
     @cached_property
     def _log(self):
@@ -88,6 +82,12 @@ class SqlExecutionMixin:
     def _execute_queries(self, queries: str, **kwargs):
         return list(self._execute_string(dedent(queries), **kwargs))
 
+    def execute_query(self, query: str, **kwargs):
+        return self._execute_query(query, **kwargs)
+
+    def execute_queries(self, queries: str, **kwargs):
+        return self._execute_queries(queries, **kwargs)
+
     def use(self, object_type: ObjectType, name: str):
         try:
             self._execute_query(f"use {object_type.value.sf_name} {name}")
@@ -147,11 +147,11 @@ class SqlExecutionMixin:
                 self.use(object_type=ObjectType.WAREHOUSE, name=prev_wh)
 
     def create_password_secret(
-        self, name: str, username: str, password: str
+        self, name: FQN, username: str, password: str
     ) -> SnowflakeCursor:
         return self._execute_query(
             f"""
-            create secret {name}
+            create secret {name.sql_identifier}
             type = password
             username = '{username}'
             password = '{password}'
@@ -159,11 +159,11 @@ class SqlExecutionMixin:
         )
 
     def create_api_integration(
-        self, name: str, api_provider: str, allowed_prefix: str, secret: Optional[str]
+        self, name: FQN, api_provider: str, allowed_prefix: str, secret: Optional[str]
     ) -> SnowflakeCursor:
         return self._execute_query(
             f"""
-            create api integration {name}
+            create api integration {name.sql_identifier}
             api_provider = {api_provider}
             api_allowed_prefixes = ('{allowed_prefix}')
             allowed_authentication_secrets = ({secret if secret else ''})
@@ -254,6 +254,22 @@ class SqlExecutionMixin:
         return show_obj_row
 
 
+class SqlExecutionMixin(SqlExecutor):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._snowpark_session = None
+
+    @property
+    def snowpark_session(self):
+        if not self._snowpark_session:
+            from snowflake.snowpark.session import Session
+
+            self._snowpark_session = Session.builder.configs(
+                {"connection": self._conn}
+            ).create()
+        return self._snowpark_session
+
+
 class VerboseCursor(SnowflakeCursor):
     def execute(self, command: str, *args, **kwargs):
         cli_console.message(command)

snowflake/cli/api/utils/definition_rendering.py

@@ -26,7 +26,7 @@ from snowflake.cli.api.project.schemas.project_definition import (
     build_project_definition,
 )
 from snowflake.cli.api.project.schemas.updatable_model import context
-from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
+from snowflake.cli.api.rendering.jinja import CONTEXT_KEY, FUNCTION_KEY
 from snowflake.cli.api.rendering.project_definition_templates import (
     get_project_definition_cli_jinja_env,
 )
@@ -344,7 +344,7 @@ def render_definition_template(
     _validate_env_section(definition.get("env", {}))
 
     # add available templating functions
-    project_context["fn"] = get_templating_functions()
+    project_context[FUNCTION_KEY] = get_templating_functions()
 
     referenced_vars = _get_referenced_vars_in_definition(template_env, definition)
 
@@ -374,10 +374,22 @@ def render_definition_template(
     )
 
     project_definition = build_project_definition(**definition)
+
+    # Use the values originally provided by the user as the template context
+    # This intentionally doesn't reflect any field changes made by
+    # validators, to minimize user surprise when templating values
     project_context[CONTEXT_KEY] = definition
+
     # Use `ProjectEnvironment` in project context in order to
     # handle env variables overrides from OS env and from CLI arguments.
     project_context[CONTEXT_KEY]["env"] = ProjectEnvironment(
         default_env=project_context[CONTEXT_KEY].get("env"), override_env=override_env
     )
     return ProjectProperties(project_definition, project_context)
+
+
+def raw_project_properties(definition: Definition) -> ProjectProperties:
+    """
+    Returns the raw project definition data without any templating.
+    """
+    return ProjectProperties(build_project_definition(**definition), {})

{snowflake_cli_labs-2.8.0rc0.dist-info → snowflake_cli_labs-3.0.0rc0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli-labs
-Version: 2.8.0rc0
+Version: 3.0.0rc0
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -216,7 +216,7 @@ Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
 Classifier: Programming Language :: SQL
 Classifier: Topic :: Database
-Requires-Python: >=3.8
+Requires-Python: >=3.10
 Requires-Dist: gitpython==3.1.43
 Requires-Dist: jinja2==3.1.4
 Requires-Dist: packaging
@@ -225,20 +225,20 @@ Requires-Dist: pluggy==1.5.0
 Requires-Dist: pydantic==2.8.2
 Requires-Dist: pyyaml==6.0.1
 Requires-Dist: requests==2.32.3
-Requires-Dist: requirements-parser==0.9.0
+Requires-Dist: requirements-parser==0.10.2
 Requires-Dist: rich==13.7.1
 Requires-Dist: setuptools==70.3.0
-Requires-Dist: snowflake-connector-python[secure-local-storage]==3.11.0
+Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.0
 Requires-Dist: snowflake-core==0.8.0; python_version < '3.12'
 Requires-Dist: snowflake-snowpark-python>=1.15.0; python_version < '3.12'
-Requires-Dist: tomlkit==0.13.0
-Requires-Dist: typer==0.12.3
+Requires-Dist: tomlkit==0.13.2
+Requires-Dist: typer==0.12.4
 Requires-Dist: urllib3<2.3,>=1.24.3
 Provides-Extra: development
-Requires-Dist: coverage==7.6.0; extra == 'development'
+Requires-Dist: coverage==7.6.1; extra == 'development'
 Requires-Dist: pre-commit>=3.5.0; extra == 'development'
 Requires-Dist: pytest-randomly==3.15.0; extra == 'development'
-Requires-Dist: pytest==8.3.1; extra == 'development'
+Requires-Dist: pytest==8.3.2; extra == 'development'
 Requires-Dist: syrupy==4.6.1; extra == 'development'
 Description-Content-Type: text/markdown
 
@@ -282,12 +282,12 @@ Cheatsheet: https://github.com/Snowflake-Labs/sf-cheatsheets/blob/main/snowflake
 
 ## Install Snowflake CLI
 
-### Install with pip (PyPi)
+### Install with pipx (PyPi)
 
-Requires Python >= 3.8
+We recommend installing Snowflake CLI in isolated environment using [pipx](https://pipx.pypa.io/stable/). Requires Python >= 3.10
 
 ```bash
-pip install snowflake-cli-labs
+pipx install snowflake-cli-labs
 snow --help
 ```
 
@@ -303,7 +303,7 @@ snow --help
 
 ### Install from source
 
-Requires Python >= 3.8 and git
+Requires Python >= 3.10 and git
 
 ```bash
 git clone https://github.com/snowflakedb/snowflake-cli