snowflake-cli-labs 3.0.0rc3__py3-none-any.whl → 3.0.0rc5__py3-none-any.whl

snowflake/cli/_plugins/workspace/commands.py

@@ -271,3 +271,36 @@ def version_create(
         interactive=interactive,
         force=force,
     )
+
+
+@version.command(name="drop", requires_connection=True, hidden=True)
+@with_project_definition()
+def version_drop(
+    entity_id: str = typer.Option(
+        help="The ID of the entity you want to create a version for.",
+    ),
+    version: Optional[str] = typer.Argument(
+        None,
+        help=f"""Version to define in your application package. If the version already exists, an auto-incremented patch is added to the version instead. Defaults to the version specified in the `manifest.yml` file.""",
+    ),
+    interactive: bool = InteractiveOption,
+    force: Optional[bool] = ForceOption,
+    **options,
+):
+    """
+    Drops a version defined for your entity. Versions can either be passed in as an argument to the command or read from the `manifest.yml` file.
+    Dropping patches is not allowed.
+    """
+
+    cli_context = get_cli_context()
+    ws = WorkspaceManager(
+        project_definition=cli_context.project_definition,
+        project_root=cli_context.project_root,
+    )
+    ws.perform_action(
+        entity_id,
+        EntityActions.VERSION_CREATE,
+        version=version,
+        interactive=interactive,
+        force=force,
+    )

snowflake/cli/api/cli_global_context.py

@@ -22,6 +22,7 @@ from typing import TYPE_CHECKING, Iterator
 
 from snowflake.cli.api.connections import ConnectionContext, OpenConnectionCache
 from snowflake.cli.api.exceptions import MissingConfiguration
+from snowflake.cli.api.metrics import CLIMetrics
 from snowflake.cli.api.output.formats import OutputFormat
 from snowflake.cli.api.rendering.jinja import CONTEXT_KEY
 from snowflake.connector import SnowflakeConnection
@@ -46,6 +47,8 @@ class _CliGlobalContextManager:
     experimental: bool = False
     enable_tracebacks: bool = True
 
+    metrics: CLIMetrics = field(default_factory=CLIMetrics)
+
     project_path_arg: str | None = None
     project_is_optional: bool = True
     project_env_overrides_args: dict[str, str] = field(default_factory=dict)
@@ -152,6 +155,10 @@ class _CliGlobalContextAccess:
     def enable_tracebacks(self) -> bool:
         return self._manager.enable_tracebacks
 
+    @property
+    def metrics(self):
+        return self._manager.metrics
+
     @property
     def output_format(self) -> OutputFormat:
         return self._manager.output_format

snowflake/cli/api/commands/decorators.py

@@ -29,10 +29,12 @@ from snowflake.cli.api.commands.flags import (
     DiagAllowlistPathOption,
     DiagLogPathOption,
     EnableDiagOption,
+    HostOption,
     MasterTokenOption,
     MfaPasscodeOption,
     OutputFormatOption,
     PasswordOption,
+    PortOption,
     PrivateKeyPathOption,
     RoleOption,
     SchemaOption,
@@ -210,6 +212,18 @@ GLOBAL_CONNECTION_OPTIONS = [
         annotation=Optional[str],
         default=ConnectionOption,
     ),
+    inspect.Parameter(
+        "host",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[str],
+        default=HostOption,
+    ),
+    inspect.Parameter(
+        "port",
+        inspect.Parameter.KEYWORD_ONLY,
+        annotation=Optional[int],
+        default=PortOption,
+    ),
     inspect.Parameter(
         "account",
         inspect.Parameter.KEYWORD_ONLY,

snowflake/cli/api/commands/flags.py

@@ -100,6 +100,24 @@ TemporaryConnectionOption = typer.Option(
     rich_help_panel=_CONNECTION_SECTION,
 )
 
+HostOption = typer.Option(
+    None,
+    "--host",
+    help="Host address for the connection. Overrides the value specified for the connection.",
+    callback=_connection_callback("host"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
+PortOption = typer.Option(
+    None,
+    "--port",
+    help="Port for the connection. Overrides the value specified for the connection.",
+    callback=_connection_callback("port"),
+    show_default=False,
+    rich_help_panel=_CONNECTION_SECTION,
+)
+
 AccountOption = typer.Option(
     None,
     "--account",

snowflake/cli/api/config.py

@@ -130,12 +130,21 @@ def config_init(config_file: Optional[Path]):
     create_initial_loggers()
 
 
-def add_connection(name: str, connection_config: ConnectionConfig):
-    set_config_value(
-        section=CONNECTIONS_SECTION,
-        key=name,
-        value=connection_config.to_dict_of_all_non_empty_values(),
-    )
+def add_connection_to_proper_file(name: str, connection_config: ConnectionConfig):
+    if CONNECTIONS_FILE.exists():
+        existing_connections = _read_connections_toml()
+        existing_connections.update(
+            {name: connection_config.to_dict_of_all_non_empty_values()}
+        )
+        _update_connections_toml(existing_connections)
+        return CONNECTIONS_FILE
+    else:
+        set_config_value(
+            section=CONNECTIONS_SECTION,
+            key=name,
+            value=connection_config.to_dict_of_all_non_empty_values(),
+        )
+        return CONFIG_MANAGER.file_path
 
 
 _DEFAULT_LOGS_CONFIG = {
@@ -359,3 +368,13 @@ def get_feature_flags_section() -> Dict[str, bool | Literal["UNKNOWN"]]:
             return "UNKNOWN"
 
     return {k: _bool_or_unknown(v) for k, v in flags.items()}
+
+
+def _read_connections_toml() -> dict:
+    with open(CONNECTIONS_FILE, "r") as f:
+        return tomlkit.loads(f.read()).unwrap()
+
+
+def _update_connections_toml(connections: dict):
+    with open(CONNECTIONS_FILE, "w") as f:
+        f.write(tomlkit.dumps(connections))

snowflake/cli/api/connections.py

@@ -36,6 +36,8 @@ schema_pattern = re.compile(r".+\..+")
 class ConnectionContext:
     # FIXME: can reduce duplication using config.ConnectionConfig
     connection_name: Optional[str] = None
+    host: Optional[str] = None
+    port: Optional[int] = None
     account: Optional[str] = None
     database: Optional[str] = None
     role: Optional[str] = None
@@ -71,7 +73,7 @@ class ConnectionContext:
         Raises KeyError if a non-property is specified as a key.
         """
         field_map = {field.name: field for field in fields(self)}
-        for (key, value) in updates.items():
+        for key, value in updates.items():
             # ensure key represents a property
             if key not in field_map:
                 raise KeyError(f"{key} is not a field of {self.__class__.__name__}")

snowflake/cli/api/entities/common.py

@@ -13,6 +13,7 @@ class EntityActions(str, Enum):
 
     VERSION_LIST = "action_version_list"
     VERSION_CREATE = "action_version_create"
+    VERSION_DROP = "action_version_drop"
 
 
 T = TypeVar("T")

snowflake/cli/api/entities/utils.py

@@ -31,6 +31,7 @@ from snowflake.cli.api.errno import (
     NO_WAREHOUSE_SELECTED_IN_SESSION,
 )
 from snowflake.cli.api.exceptions import SnowflakeSQLExecutionError
+from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.entities.common import PostDeployHook
 from snowflake.cli.api.rendering.sql_templates import (
     choose_sql_jinja_env_based_on_template_syntax,
@@ -249,6 +250,8 @@ def execute_post_deploy_hooks(
     if not post_deploy_hooks:
         return
 
+    get_cli_context().metrics.set_counter(CLICounterField.POST_DEPLOY_SCRIPTS, 1)
+
     with console.phase(f"Executing {deployed_object_type} post-deploy actions"):
         sql_scripts_paths = []
         for hook in post_deploy_hooks:

snowflake/cli/api/metrics.py

@@ -0,0 +1,92 @@
+# 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 typing import Dict, Optional
+
+
+class _TypePrefix:
+    FEATURES = "features"
+
+
+class _DomainPrefix:
+    GLOBAL = "global"
+    APP = "app"
+    SQL = "sql"
+
+
+class CLICounterField:
+    """
+    for each counter field we're adopting a convention of
+    <type>.<domain>.<name>
+    for example, if we're tracking a global feature, then the field name would be
+    features.global.feature_name
+
+    The metrics API is implemented to be generic, but we are adopting a convention
+    for feature tracking with the following model for a given command execution:
+    * counter not present -> feature is not available
+    * counter == 0 -> feature is available, but not used
+    * counter == 1 -> feature is used
+    this makes it easy to compute percentages for feature dashboards in Snowsight
+    """
+
+    TEMPLATES_PROCESSOR = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.GLOBAL}.templates_processor"
+    )
+    SQL_TEMPLATES = f"{_TypePrefix.FEATURES}.{_DomainPrefix.SQL}.sql_templates"
+    PDF_TEMPLATES = f"{_TypePrefix.FEATURES}.{_DomainPrefix.GLOBAL}.pdf_templates"
+    SNOWPARK_PROCESSOR = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.snowpark_processor"
+    )
+    POST_DEPLOY_SCRIPTS = (
+        f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.post_deploy_scripts"
+    )
+    PACKAGE_SCRIPTS = f"{_TypePrefix.FEATURES}.{_DomainPrefix.APP}.package_scripts"
+
+
+class CLIMetrics:
+    """
+    Class to track various metrics across the execution of a command
+    """
+
+    def __init__(self):
+        self._counters: Dict[str, int] = {}
+
+    def __eq__(self, other):
+        if isinstance(other, CLIMetrics):
+            return self._counters == other._counters
+        return False
+
+    def get_counter(self, name: str) -> Optional[int]:
+        return self._counters.get(name)
+
+    def set_counter(self, name: str, value: int) -> None:
+        self._counters[name] = value
+
+    def set_counter_default(self, name: str, value: int) -> None:
+        """
+        sets the counter if it does not already exist
+        """
+        if name not in self._counters:
+            self.set_counter(name, value)
+
+    def increment_counter(self, name: str, value: int = 1) -> None:
+        if name not in self._counters:
+            self.set_counter(name, value)
+        else:
+            self._counters[name] += value
+
+    @property
+    def counters(self) -> Dict[str, int]:
+        # return a copy of the original dict to avoid mutating the original
+        return self._counters.copy()

snowflake/cli/api/project/definition_conversion.py

@@ -6,7 +6,7 @@ from typing import Any, Dict, Literal, Optional
 
 from click import ClickException
 from snowflake.cli._plugins.nativeapp.artifacts import (
-    build_bundle,
+    BundleMap,
 )
 from snowflake.cli._plugins.snowpark.common import is_name_a_templated_one
 from snowflake.cli.api.constants import (
@@ -41,15 +41,41 @@ from snowflake.cli.api.rendering.jinja import get_basic_jinja_env
 log = logging.getLogger(__name__)
 
 
+def _is_field_defined(template_context: Optional[Dict[str, Any]], *path: str) -> bool:
+    """
+    Determines if a field is defined in the provided template context. For example,
+
+    _is_field_defined({"ctx": {"native_app": {"bundle_root": "my_root"}}}, "ctx", "native_app", "bundle_root")
+
+    returns True. If the provided template context is None, this function returns True for all paths.
+
+    """
+    if template_context is None:
+        return True  # No context, so assume that all variables are defined
+
+    current_dict = template_context
+    for key in path:
+        if not isinstance(current_dict, dict):
+            return False
+        if key not in current_dict:
+            return False
+        current_dict = current_dict[key]
+
+    return True
+
+
 def convert_project_definition_to_v2(
-    project_root: Path, pd: ProjectDefinition, accept_templates: bool = False
+    project_root: Path,
+    pd: ProjectDefinition,
+    accept_templates: bool = False,
+    template_context: Optional[Dict[str, Any]] = None,
 ) -> ProjectDefinitionV2:
     _check_if_project_definition_meets_requirements(pd, accept_templates)
 
     snowpark_data = convert_snowpark_to_v2_data(pd.snowpark) if pd.snowpark else {}
     streamlit_data = convert_streamlit_to_v2_data(pd.streamlit) if pd.streamlit else {}
     native_app_data = (
-        convert_native_app_to_v2_data(project_root, pd.native_app)
+        convert_native_app_to_v2_data(project_root, pd.native_app, template_context)
         if pd.native_app
         else {}
     )
@@ -170,7 +196,9 @@ def convert_streamlit_to_v2_data(streamlit: Streamlit) -> Dict[str, Any]:
 
 
 def convert_native_app_to_v2_data(
-    project_root, native_app: NativeApp
+    project_root,
+    native_app: NativeApp,
+    template_context: Optional[Dict[str, Any]] = None,
 ) -> Dict[str, Any]:
     def _make_meta(obj: Application | Package):
         meta = {}
@@ -188,17 +216,22 @@ def convert_native_app_to_v2_data(
         # 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
-        try:
-            bundle_map = build_bundle(
-                project_root, Path(native_app.deploy_root), native_app.artifacts
-            )
-        except Exception as e:
-            # The manifest field is required, so we can't gracefully handle bundle failures
-            raise ClickException(
-                f"{e}\nCould not bundle Native App artifacts, unable to perform migration"
-            ) from e
-
-        manifest_path = bundle_map.to_project_path(Path("manifest.yml"))
+        bundle_map = BundleMap(
+            project_root=project_root, deploy_root=Path(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(
@@ -208,7 +241,7 @@ def convert_native_app_to_v2_data(
 
         # Use a POSIX path to be consistent with other migrated fields
         # which use POSIX paths as default values
-        return manifest_path.as_posix()
+        return manifest_path.relative_to(project_root).as_posix()
 
     def _make_template(template: str) -> str:
         return f"{PROJECT_TEMPLATE_VARIABLE_OPENING} {template} {PROJECT_TEMPLATE_VARIABLE_CLOSING}"
@@ -250,14 +283,24 @@ def convert_native_app_to_v2_data(
         "identifier": package_identifier,
         "manifest": _find_manifest(),
         "artifacts": native_app.artifacts,
-        "bundle_root": native_app.bundle_root,
-        "generated_root": native_app.generated_root,
-        "deploy_root": native_app.deploy_root,
-        "stage": native_app.source_stage,
-        "scratch_stage": native_app.scratch_stage,
     }
+
+    if _is_field_defined(template_context, "ctx", "native_app", "bundle_root"):
+        package["bundle_root"] = native_app.bundle_root
+    if _is_field_defined(template_context, "ctx", "native_app", "generated_root"):
+        package["generated_root"] = native_app.generated_root
+    if _is_field_defined(template_context, "ctx", "native_app", "deploy_root"):
+        package["deploy_root"] = native_app.deploy_root
+    if _is_field_defined(template_context, "ctx", "native_app", "source_stage"):
+        package["stage"] = native_app.source_stage
+    if _is_field_defined(template_context, "ctx", "native_app", "scratch_stage"):
+        package["scratch_stage"] = native_app.scratch_stage
+
     if native_app.package:
-        package["distribution"] = native_app.package.distribution
+        if _is_field_defined(
+            template_context, "ctx", "native_app", "package", "distribution"
+        ):
+            package["distribution"] = native_app.package.distribution
         package_meta = _make_meta(native_app.package)
         if native_app.package.scripts:
             converted_post_deploy_hooks = _convert_package_script_files(
@@ -289,6 +332,10 @@ def convert_native_app_to_v2_data(
     if native_app.application:
         if app_meta := _make_meta(native_app.application):
             app["meta"] = app_meta
+        if _is_field_defined(
+            template_context, "ctx", "native_app", "application", "debug"
+        ):
+            app["debug"] = native_app.application.debug
 
     return {
         "entities": {

snowflake/cli/api/project/definition_manager.py

@@ -41,7 +41,7 @@ class DefinitionManager:
     USER_DEFINITION_FILENAME = "snowflake.local.yml"
 
     project_root: Path
-    _project_config_paths: List[Path]
+    project_config_paths: List[Path]
 
     def __init__(
         self,
@@ -53,12 +53,12 @@ class DefinitionManager:
         )
 
         self.project_root = project_root
-        self._project_config_paths = self._find_definition_files(self.project_root)
+        self.project_config_paths = self._find_definition_files(self.project_root)
         self._context_overrides = context_overrides
 
     @functools.cached_property
     def has_definition_file(self):
-        return len(self._project_config_paths) > 0
+        return len(self.project_config_paths) > 0
 
     @staticmethod
     def _find_definition_files(project_root: Path) -> List[Path]:
@@ -126,11 +126,11 @@ class DefinitionManager:
 
     @functools.cached_property
     def _project_properties(self) -> ProjectProperties:
-        return load_project(self._project_config_paths, self._context_overrides)
+        return load_project(self.project_config_paths, self._context_overrides)
 
     @functools.cached_property
     def _raw_project_data(self) -> ProjectProperties:
-        return load_project(self._project_config_paths, {}, False)
+        return load_project(self.project_config_paths, {}, False)
 
     @functools.cached_property
     def project_definition(self) -> ProjectDefinitionV1:

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

@@ -16,14 +16,12 @@ from __future__ import annotations
 
 from typing import Dict, List, Union, get_args
 
-from snowflake.cli._plugins.nativeapp.application_entity import ApplicationEntity
-from snowflake.cli._plugins.nativeapp.application_entity_model import (
+from snowflake.cli._plugins.nativeapp.entities.application import (
+    ApplicationEntity,
     ApplicationEntityModel,
 )
-from snowflake.cli._plugins.nativeapp.application_package_entity import (
+from snowflake.cli._plugins.nativeapp.entities.application_package import (
     ApplicationPackageEntity,
-)
-from snowflake.cli._plugins.nativeapp.application_package_entity_model import (
     ApplicationPackageEntityModel,
 )
 from snowflake.cli._plugins.snowpark.snowpark_entity import (

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

@@ -19,9 +19,7 @@ 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._plugins.nativeapp.application_entity_model import (
-    ApplicationEntityModel,
-)
+from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
 from snowflake.cli.api.project.errors import SchemaValidationError
 from snowflake.cli.api.project.schemas.entities.common import (
     TargetField,

snowflake/cli/api/rendering/sql_templates.py

@@ -21,6 +21,7 @@ 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.metrics import CLICounterField
 from snowflake.cli.api.rendering.jinja import (
     CONTEXT_KEY,
     FUNCTION_KEY,
@@ -96,4 +97,9 @@ def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
     context_data = get_cli_context().template_context
     context_data.update(data)
     env = choose_sql_jinja_env_based_on_template_syntax(content)
+
+    get_cli_context().metrics.set_counter(
+        CLICounterField.SQL_TEMPLATES, int(has_sql_templates(content))
+    )
+
     return env.from_string(content).render(context_data)

snowflake/cli/api/rest_api.py

@@ -21,8 +21,9 @@ from typing import Any, Dict, Optional
 from click import ClickException
 from snowflake.cli.api.constants import SF_REST_API_URL_PREFIX
 from snowflake.connector.connection import SnowflakeConnection
-from snowflake.connector.errors import BadRequest, InterfaceError
+from snowflake.connector.errors import BadRequest
 from snowflake.connector.network import SnowflakeRestful
+from snowflake.connector.vendored.requests.exceptions import HTTPError
 
 log = logging.getLogger(__name__)
 
@@ -47,10 +48,10 @@ class RestApi:
         Check whether [get] endpoint exists under given URL.
         """
         try:
-            result = self.send_rest_request(url, method="get")
-            return bool(result) or result == []
-        except InterfaceError as err:
-            if "404 Not Found" in str(err):
+            self.send_rest_request(url, method="get")
+            return True
+        except HTTPError as err:
+            if err.response.status_code == 404:
                 return False
             raise err
 
@@ -60,6 +61,10 @@ class RestApi:
             return bool(result)
         except BadRequest:
             return False
+        except HTTPError as err:
+            if err.response.status_code == 404:
+                return False
+            raise err
 
     def send_rest_request(
         self, url: str, method: str, data: Optional[Dict[str, Any]] = None
@@ -91,6 +96,7 @@ class RestApi:
             token=self.rest.token,
             data=json.dumps(data if data else {}),
             no_retry=True,
+            raise_raw_http_failure=True,
         )
 
     def _database_exists(self, db_name: str) -> bool:

snowflake/cli/api/utils/definition_rendering.py

@@ -19,8 +19,10 @@ from typing import Any, Optional
 
 from jinja2 import Environment, TemplateSyntaxError, nodes
 from packaging.version import Version
+from snowflake.cli.api.cli_global_context import get_cli_context
 from snowflake.cli.api.console import cli_console as cc
 from snowflake.cli.api.exceptions import CycleDetectedError, InvalidTemplate
+from snowflake.cli.api.metrics import CLICounterField
 from snowflake.cli.api.project.schemas.project_definition import (
     ProjectProperties,
     build_project_definition,
@@ -266,6 +268,12 @@ def _get_referenced_vars_in_definition(
     return referenced_vars
 
 
+def _has_referenced_vars_in_definition(
+    template_env: TemplatedEnvironment, definition: Definition
+) -> bool:
+    return len(_get_referenced_vars_in_definition(template_env, definition)) > 0
+
+
 def _template_version_warning():
     cc.warning(
         "Ignoring template pattern in project definition file. "
@@ -291,6 +299,17 @@ def _add_defaults_to_definition(original_definition: Definition) -> Definition:
     return definition_with_defaults
 
 
+def _update_metrics(template_env: TemplatedEnvironment, definition: Definition):
+    metrics = get_cli_context().metrics
+
+    # render_definition_template is invoked multiple times both by the user
+    # and by us so we should make sure we don't overwrite a 1 with a 0 here
+    metrics.set_counter_default(CLICounterField.PDF_TEMPLATES, 0)
+
+    if _has_referenced_vars_in_definition(template_env, definition):
+        metrics.set_counter(CLICounterField.PDF_TEMPLATES, 1)
+
+
 def render_definition_template(
     original_definition: Optional[Definition], context_overrides: Context
 ) -> ProjectProperties:
@@ -326,10 +345,7 @@ def render_definition_template(
         definition["definition_version"]
     ) < Version("1.1"):
         try:
-            referenced_vars = _get_referenced_vars_in_definition(
-                template_env, definition
-            )
-            if referenced_vars:
+            if _has_referenced_vars_in_definition(template_env, definition):
                 _template_version_warning()
         except Exception:
             # also warn on Exception, as it means the user is incorrectly attempting to use templating
@@ -340,6 +356,10 @@ def render_definition_template(
         project_context[CONTEXT_KEY]["env"] = environment_overrides
         return ProjectProperties(project_definition, project_context)
 
+    # need to have the metrics added here since we add defaults to the
+    # definition that the user might not have added themselves later
+    _update_metrics(template_env, definition)
+
     definition = _add_defaults_to_definition(definition)
     project_context = {CONTEXT_KEY: definition}
 

{snowflake_cli_labs-3.0.0rc3.dist-info → snowflake_cli_labs-3.0.0rc5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli-labs
-Version: 3.0.0rc3
+Version: 3.0.0rc5
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues
@@ -222,7 +222,7 @@ Requires-Dist: jinja2==3.1.4
 Requires-Dist: packaging
 Requires-Dist: pip
 Requires-Dist: pluggy==1.5.0
-Requires-Dist: pydantic==2.9.1
+Requires-Dist: pydantic==2.9.2
 Requires-Dist: pyyaml==6.0.2
 Requires-Dist: requests==2.32.3
 Requires-Dist: requirements-parser==0.11.0
@@ -240,6 +240,8 @@ Requires-Dist: pre-commit>=3.5.0; extra == 'development'
 Requires-Dist: pytest-randomly==3.15.0; extra == 'development'
 Requires-Dist: pytest==8.3.3; extra == 'development'
 Requires-Dist: syrupy==4.7.1; extra == 'development'
+Provides-Extra: packaging
+Requires-Dist: pyinstaller~=6.10; extra == 'packaging'
 Description-Content-Type: text/markdown
 
 <!--