snowflake-cli-labs 2.7.0rc4__tar.gz → 2.8.0rc1__tar.gz

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/.pre-commit-config.yaml

@@ -24,7 +24,7 @@ repos:
     rev: v0.990
     hooks:
       - id: mypy
-        additional_dependencies: [types-all]
+        additional_dependencies: [types-pkg-resources==0.1.3, types-all==1.0.0]
   - repo: https://github.com/codespell-project/codespell
     rev: v2.2.4
     hooks:

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/CONTRIBUTING.md

@@ -69,40 +69,45 @@ or by running `pytest` inside activated environment.
 Every integration test should have `integration` mark. By default, integration tests are not execute when running `pytest`.
 
 To execute only integration tests run `hatch run integration:test` or `pytest -m integration` inside environment.
-### Connection parameters in `config.toml`
 
-Add the following connection to your `config.toml`
+### User setup
 
-```toml
-[connections.integration]
-host = <host>
-account = <account_name>
-user = <user>
-password = <password>
-```
+Integration tests require environment variables to be set up. Parameters must use the following format:
 
-### Connection parameters in environment parameters
+``SNOWFLAKE_CONNECTIONS_INTEGRATION_<key>=<value>``
 
-Parameters must use the following format:
+where ``<key>`` is the name of the key. The following environment variables are required:
 
-``SNOWFLAKE_CONNECTIONS_INTEGRATION_<key>=<value>``
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_HOST`
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_ACCOUNT`
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_USER`
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_PASSWORD` or `SNOWFLAKE_CONNECTIONS_INTEGRATION_PRIVATE_KEY_PATH` (if using private key authentication `SNOWFLAKE_CONNECTIONS_INTEGRATION_PASSWORD=SNOWFLAKE_JWT` should be set)
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_ROLE`
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_DATABASE`
+- `SNOWFLAKE_CONNECTIONS_INTEGRATION_WAREHOUSE`
 
-where ``<key>`` is the name of the key
+### Integration account setup script
 
-For example: SNOWFLAKE_CONNECTIONS_INTEGRATION_ACCOUNT="my-account"
+To set up an account for integration tests, run the following script with `ACCOUNTADMIN` role:
 
-List of required parameter keys:
-- host
-- account
-- user
-- password
+```bash
+snow sql \
+  -f tests_integration/scripts/integration_account_setup.sql \
+  -D "user=${SNOWFLAKE_CONNECTIONS_INTEGRATION_USER}" \
+  -D "role=${SNOWFLAKE_CONNECTIONS_INTEGRATION_ROLE}" \
+  -D "warehouse=${SNOWFLAKE_CONNECTIONS_INTEGRATION_WAREHOUSE}" \
+  -D "main_database=${SNOWFLAKE_CONNECTIONS_INTEGRATION_DATABASE}"\
+  -c <your_connection_name>
+```
 
-### User setup
+Note: Before running the script, set up your environment variables.
+
+### Build and push Docker images
 
-Run the script with ACCOUNTADMIN role
+To build and push all required Docker images, run the following script:
 
 ```bash
-tests_integration/scripts/integration_account_setup.sql
+./tests_integration/spcs/docker/build_and_push_all.sh
 ```
 
 ## Remote debugging with PyCharm or IntelliJ

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli-labs
-Version: 2.7.0rc4
+Version: 2.8.0rc1
 Summary: Snowflake CLI
 Project-URL: Source code, https://github.com/snowflakedb/snowflake-cli
 Project-URL: Bug Tracker, https://github.com/snowflakedb/snowflake-cli/issues

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/RELEASE-NOTES.md

@@ -24,6 +24,23 @@
 ## Fixes and improvements
 
 
+# v2.8.0
+## Backward incompatibility
+
+## Deprecations
+  * Added deprecation warning for `native_app.package.scripts` in project definition file.
+
+## New additions
+* Added support for project definition file defaults in templates.
+* Added support for `native_app.package.post_deploy` scripts in project definition file.
+  * These scripts will execute whenever a Native App Package is created or updated.
+  * Currently only supports SQL scripts: `post_deploy: [{sql_script: script.sql}]`.
+
+## Fixes and improvements
+* Fix return values of `snow snowpark list`, `describe` and `drop` commands.
+* Show warnings returned by Snowflake when `snow app run` is successful.
+
+
 # v2.7.0
 
 # Unreleased version

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/scripts/cleanup.py

@@ -17,6 +17,7 @@ import os
 import typing as t
 from datetime import datetime, timedelta
 
+from snowflake.cli._app.snow_connector import update_connection_details_with_private_key
 from snowflake.snowpark.session import Session
 
 
@@ -49,18 +50,21 @@ def remove_resources(single: str, plural: str, known_instances: t.List[str], rol
 
 
 if __name__ == "__main__":
-    role = "INTEGRATION_TESTS"
-    session = Session.builder.configs(
-        {
-            "account": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_ACCOUNT"),
-            "user": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_USER"),
-            "password": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_PASSWORD"),
-            "database": "SNOWCLI_DB",
-            "role": role,
-        }
-    ).create()
+    role = os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_ROLE", "INTEGRATION_TESTS")
+    config = {
+        "authenticator": "SNOWFLAKE_JWT",
+        "account": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_ACCOUNT"),
+        "user": os.getenv("SNOWFLAKE_CONNECTIONS_INTEGRATION_USER"),
+        "private_key_path": os.getenv(
+            "SNOWFLAKE_CONNECTIONS_INTEGRATION_PRIVATE_KEY_PATH"
+        ),
+        "database": "SNOWCLI_DB",
+        "role": role,
+    }
+    update_connection_details_with_private_key(config)
+    session = Session.builder.configs(config).create()
 
-    session.use_role("INTEGRATION_TESTS")
+    session.use_role(role)
 
     known_objects: t.Dict[t.Tuple[str, str], t.List[str]] = {
         ("database", "databases"): [

snowflake_cli_labs-2.8.0rc1/scripts/run_tests_with_retry.py

@@ -0,0 +1,38 @@
+# Copyright (c) 2024 Snowflake Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import sys
+from subprocess import run
+
+test_type = sys.argv[1].title()
+pytest = ["pytest"] + sys.argv[2:]
+
+
+def p(*s):
+    print(*s, file=sys.stderr, flush=True)
+
+
+# Run tests once
+if run(pytest, check=False).returncode == 0:
+    sys.exit(0)
+
+# Then run the failed tests once more,
+# if they fail, the failure was most likely legitimate
+p(f"{test_type} tests failed, re-running to detect flakes")
+if (ret := run(pytest + ["--last-failed"]).returncode) != 0:
+    p(f"{test_type} tests re-run failed")
+    sys.exit(ret)
+
+# If they succeed, they are flaky, we should tell the user
+p(f"{test_type} tests passed during retry, these are most likely flaky")

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/__about__.py

@@ -14,4 +14,4 @@
 
 from __future__ import annotations
 
-VERSION = "2.7.0rc4"
+VERSION = "2.8.0rc1"

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/definition.py

@@ -21,13 +21,12 @@ import yaml
 from snowflake.cli.api.cli_global_context import cli_context
 from snowflake.cli.api.constants import DEFAULT_SIZE_LIMIT_MB
 from snowflake.cli.api.project.schemas.project_definition import (
-    ProjectDefinition,
     ProjectProperties,
 )
 from snowflake.cli.api.project.util import (
     append_to_identifier,
-    clean_identifier,
     get_env_username,
+    sanitize_identifier,
     to_identifier,
 )
 from snowflake.cli.api.secure_path import SecurePath
@@ -70,40 +69,8 @@ def load_project(
     return render_definition_template(merged_definitions, context_overrides or {})
 
 
-def generate_local_override_yml(
-    project: ProjectDefinition,
-) -> ProjectDefinition:
-    """
-    Generates defaults for optional keys in the same YAML structure as the project
-    schema. The returned YAML object can be saved directly to a file, if desired.
-    A connection is made using global context to resolve current role and warehouse.
-    """
-    conn = cli_context.connection
-    user = clean_identifier(get_env_username() or DEFAULT_USERNAME)
-    role = conn.role
-    warehouse = conn.warehouse
-
-    local: dict = {}
-    if project.native_app:
-        name = clean_identifier(project.native_app.name)
-        app_identifier = to_identifier(name)
-        user_app_identifier = append_to_identifier(app_identifier, f"_{user}")
-        package_identifier = append_to_identifier(app_identifier, f"_pkg_{user}")
-        local["native_app"] = {
-            "application": {
-                "name": user_app_identifier,
-                "role": role,
-                "debug": True,
-                "warehouse": warehouse,
-            },
-            "package": {"name": package_identifier, "role": role},
-        }
-
-    return project.update_from_dict(local)
-
-
 def default_app_package(project_name: str):
-    user = clean_identifier(get_env_username() or DEFAULT_USERNAME)
+    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
     return append_to_identifier(to_identifier(project_name), f"_pkg_{user}")
 
 
@@ -113,5 +80,5 @@ def default_role():
 
 
 def default_application(project_name: str):
-    user = clean_identifier(get_env_username() or DEFAULT_USERNAME)
+    user = sanitize_identifier(get_env_username() or DEFAULT_USERNAME).lower()
     return append_to_identifier(to_identifier(project_name), f"_{user}")

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/errors.py

@@ -29,10 +29,25 @@ class SchemaValidationError(ClickException):
     def __init__(self, error: ValidationError):
         errors = error.errors()
         message = f"During evaluation of {error.title} in project definition following errors were encountered:\n"
+
+        def calculate_location(e):
+            if e["loc"] is None:
+                return None
+
+            # show numbers as list indexes and strings as dictionary keys. Example: key1[0].key2
+            result = "".join(
+                f"[{item}]" if isinstance(item, int) else f".{item}"
+                for item in e["loc"]
+            )
+
+            # remove leading dot from the string if any:
+            return result[1:] if result.startswith(".") else result
+
         message += "\n".join(
             [
                 self.message_templates.get(e["type"], self.generic_message).format(
-                    **e, location=".".join(e["loc"]) if e["loc"] is not None else None
+                    **e,
+                    location=calculate_location(e),
                 )
                 for e in errors
             ]

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/entities/application_entity.py

@@ -16,7 +16,7 @@ from __future__ import annotations
 
 from typing import Literal, Optional
 
-from pydantic import AliasChoices, Field
+from pydantic import Field
 from snowflake.cli.api.project.schemas.entities.application_package_entity import (
     ApplicationPackageEntity,
 )
@@ -25,26 +25,20 @@ from snowflake.cli.api.project.schemas.entities.common import (
     TargetField,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
-    UpdatableModel,
+    DiscriminatorField,
 )
 
 
 class ApplicationEntity(EntityBase):
-    type: Literal["application"]  # noqa: A003
+    type: Literal["application"] = DiscriminatorField()  # noqa A003
     name: str = Field(
         title="Name of the application created when this entity is deployed"
     )
-    from_: ApplicationFromField = Field(
-        validation_alias=AliasChoices("from"),
+    from_: TargetField[ApplicationPackageEntity] = Field(
+        alias="from",
         title="An application package this entity should be created from",
     )
     debug: Optional[bool] = Field(
         title="Whether to enable debug mode when using a named stage to create an application object",
         default=None,
     )
-
-
-class ApplicationFromField(UpdatableModel):
-    target: TargetField[ApplicationPackageEntity] = Field(
-        title="Reference to an application package entity",
-    )

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/entities/application_package_entity.py

@@ -23,11 +23,14 @@ from snowflake.cli.api.project.schemas.entities.common import (
 )
 from snowflake.cli.api.project.schemas.native_app.package import DistributionOptions
 from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
-from snowflake.cli.api.project.schemas.updatable_model import IdentifierField
+from snowflake.cli.api.project.schemas.updatable_model import (
+    DiscriminatorField,
+    IdentifierField,
+)
 
 
 class ApplicationPackageEntity(EntityBase):
-    type: Literal["application package"]  # noqa: A003
+    type: Literal["application package"] = DiscriminatorField()  # noqa: A003
     name: str = Field(
         title="Name of the application package created when this entity is deployed"
     )

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/entities/common.py

@@ -17,10 +17,9 @@ from __future__ import annotations
 from abc import ABC
 from typing import Generic, List, Optional, TypeVar
 
-from pydantic import AliasChoices, Field, GetCoreSchemaHandler, ValidationInfo
-from pydantic_core import core_schema
+from pydantic import Field
 from snowflake.cli.api.project.schemas.native_app.application import (
-    ApplicationPostDeployHook,
+    PostDeployHook,
 )
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
@@ -36,7 +35,7 @@ class MetaField(UpdatableModel):
         title="Role to use when creating the entity object",
         default=None,
     )
-    post_deploy: Optional[List[ApplicationPostDeployHook]] = Field(
+    post_deploy: Optional[List[PostDeployHook]] = Field(
         title="Actions that will be executed after the application object is created/upgraded",
         default=None,
     )
@@ -45,7 +44,7 @@ class MetaField(UpdatableModel):
 class DefaultsField(UpdatableModel):
     schema_: Optional[str] = Field(
         title="Schema.",
-        validation_alias=AliasChoices("schema"),
+        alias="schema",
         default=None,
     )
     stage: Optional[str] = Field(
@@ -65,21 +64,15 @@ class EntityBase(ABC, UpdatableModel):
 TargetType = TypeVar("TargetType")
 
 
-class TargetField(Generic[TargetType]):
-    def __init__(self, entity_target_key: str):
-        self.value = entity_target_key
-
-    def __repr__(self):
-        return self.value
-
-    @classmethod
-    def validate(cls, value: str, info: ValidationInfo) -> TargetField:
-        return cls(value)
+class TargetField(UpdatableModel, Generic[TargetType]):
+    target: str = Field(
+        title="Reference to a target entity",
+    )
 
-    @classmethod
-    def __get_pydantic_core_schema__(
-        cls, source_type, handler: GetCoreSchemaHandler
-    ) -> core_schema.CoreSchema:
-        return core_schema.with_info_after_validator_function(
-            cls.validate, handler(str), field_name=handler.field_name
-        )
+    def get_type(self) -> type:
+        """
+        Returns the generic type of this class, indicating the entity type.
+        Pydantic extracts Generic annotations, and populates
+        them in __pydantic_generic_metadata__
+        """
+        return self.__pydantic_generic_metadata__["args"][0]

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/native_app/application.py

@@ -28,7 +28,7 @@ class SqlScriptHookType(UpdatableModel):
 
 
 # Currently sql_script is the only supported hook type. Change to a Union once other hook types are added
-ApplicationPostDeployHook = SqlScriptHookType
+PostDeployHook = SqlScriptHookType
 
 
 class Application(UpdatableModel):
@@ -48,7 +48,15 @@ class Application(UpdatableModel):
         title="When set, forces debug_mode on/off for the deployed application object",
         default=None,
     )
-    post_deploy: Optional[List[ApplicationPostDeployHook]] = Field(
+    post_deploy: Optional[List[PostDeployHook]] = Field(
         title="Actions that will be executed after the application object is created/upgraded",
         default=None,
     )
+
+
+class ApplicationV11(Application):
+    # Templated defaults only supported in v1.1+
+    name: Optional[str] = Field(
+        title="Name of the application object created when you run the snow app run command",
+        default="<% fn.concat_ids(ctx.native_app.name, '_', fn.sanitize_id(fn.get_username('unknown_user')) | lower) %>",
+    )

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/native_app/native_app.py

@@ -18,8 +18,11 @@ import re
 from typing import List, Optional, Union
 
 from pydantic import Field, field_validator
-from snowflake.cli.api.project.schemas.native_app.application import Application
-from snowflake.cli.api.project.schemas.native_app.package import Package
+from snowflake.cli.api.project.schemas.native_app.application import (
+    Application,
+    ApplicationV11,
+)
+from snowflake.cli.api.project.schemas.native_app.package import Package, PackageV11
 from snowflake.cli.api.project.schemas.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 from snowflake.cli.api.project.util import (
@@ -80,3 +83,11 @@ class NativeApp(UpdatableModel):
                 transformed_artifacts.append(PathMapping(src=artifact))
 
         return transformed_artifacts
+
+
+class NativeAppV11(NativeApp):
+    # templated defaults are only supported with version 1.1+
+    package: Optional[PackageV11] = Field(title="PackageSchema", default=PackageV11())
+    application: Optional[ApplicationV11] = Field(
+        title="Application info", default=ApplicationV11()
+    )

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/native_app/package.py

@@ -16,7 +16,8 @@ from __future__ import annotations
 
 from typing import List, Literal, Optional
 
-from pydantic import Field, field_validator
+from pydantic import Field, field_validator, model_validator
+from snowflake.cli.api.project.schemas.native_app.application import PostDeployHook
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
     UpdatableModel,
@@ -44,6 +45,10 @@ class Package(UpdatableModel):
         title="Distribution of the application package created by the Snowflake CLI",
         default="internal",
     )
+    post_deploy: Optional[List[PostDeployHook]] = Field(
+        title="Actions that will be executed after the application package object is created/updated",
+        default=None,
+    )
 
     @field_validator("scripts")
     @classmethod
@@ -53,3 +58,21 @@ class Package(UpdatableModel):
                 "package.scripts field should contain unique values. Check the list for duplicates and try again"
             )
         return input_list
+
+    @model_validator(mode="after")
+    @classmethod
+    def validate_no_scripts_and_post_deploy(cls, value: Package):
+        if value.scripts and value.post_deploy:
+            raise ValueError(
+                "package.scripts and package.post_deploy fields cannot be used together. "
+                "We recommend using package.post_deploy for all post package deploy scripts"
+            )
+        return value
+
+
+class PackageV11(Package):
+    # Templated defaults only supported in v1.1+
+    name: Optional[str] = IdentifierField(
+        title="Name of the application package created when you run the snow app run command",
+        default="<% fn.concat_ids(ctx.native_app.name, '_pkg_', fn.sanitize_id(fn.get_username('unknown_user')) | lower) %>",
+    )

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/project_definition.py

@@ -32,11 +32,13 @@ from snowflake.cli.api.project.schemas.entities.entities import (
     Entity,
     v2_entity_types_map,
 )
-from snowflake.cli.api.project.schemas.native_app.native_app import NativeApp
+from snowflake.cli.api.project.schemas.native_app.native_app import (
+    NativeApp,
+    NativeAppV11,
+)
 from snowflake.cli.api.project.schemas.snowpark.snowpark import Snowpark
 from snowflake.cli.api.project.schemas.streamlit.streamlit import Streamlit
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
-from snowflake.cli.api.utils.models import ProjectEnvironment
 from snowflake.cli.api.utils.types import Context
 from typing_extensions import Annotated
 
@@ -99,22 +101,14 @@ class DefinitionV10(_ProjectDefinitionBase):
 
 
 class DefinitionV11(DefinitionV10):
-    env: Union[Dict[str, str], ProjectEnvironment, None] = Field(
-        title="Environment specification for this project.",
+    native_app: Optional[NativeAppV11] = Field(
+        title="Native app definitions for the project", default=None
+    )
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
         default=None,
-        validation_alias="env",
-        union_mode="smart",
     )
 
-    @field_validator("env")
-    @classmethod
-    def _convert_env(
-        cls, env: Union[Dict, ProjectEnvironment, None]
-    ) -> ProjectEnvironment:
-        if isinstance(env, ProjectEnvironment):
-            return env
-        return ProjectEnvironment(default_env=(env or {}), override_env={})
-
 
 class DefinitionV20(_ProjectDefinitionBase):
     entities: Dict[str, Annotated[Entity, Field(discriminator="type")]] = Field(
@@ -147,10 +141,10 @@ class DefinitionV20(_ProjectDefinitionBase):
         for key, entity in entities.items():
             # TODO Automatically detect TargetFields to validate
             if entity.type == ApplicationEntity.get_type():
-                if isinstance(entity.from_.target, TargetField):
-                    target_key = str(entity.from_.target)
-                    target_class = entity.from_.__class__.model_fields["target"]
-                    target_type = target_class.annotation.__args__[0]
+                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)
         return entities
 
@@ -160,37 +154,26 @@ class DefinitionV20(_ProjectDefinitionBase):
     ):
         if target_key not in entities:
             raise ValueError(f"No such target: {target_key}")
-        else:
-            # Validate the target type
-            actual_target_type = entities[target_key].__class__
-            if target_type and target_type is not actual_target_type:
-                raise ValueError(
-                    f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
-                )
+
+        # Validate the target type
+        actual_target_type = entities[target_key].__class__
+        if target_type and target_type is not actual_target_type:
+            raise ValueError(
+                f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
+            )
 
     defaults: Optional[DefaultsField] = Field(
         title="Default key/value entity values that are merged recursively for each entity.",
         default=None,
     )
 
-    env: Union[Dict[str, str], ProjectEnvironment, None] = Field(
-        title="Environment specification for this project.",
+    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
         default=None,
-        validation_alias="env",
-        union_mode="smart",
     )
 
-    @field_validator("env")
-    @classmethod
-    def _convert_env(
-        cls, env: Union[Dict, ProjectEnvironment, None]
-    ) -> ProjectEnvironment:
-        if isinstance(env, ProjectEnvironment):
-            return env
-        return ProjectEnvironment(default_env=(env or {}), override_env={})
-
 
-def build_project_definition(**data):
+def build_project_definition(**data) -> ProjectDefinition:
     """
     Returns a ProjectDefinition instance with a version matching the provided definition_version value
     """

{snowflake_cli_labs-2.7.0rc4 → snowflake_cli_labs-2.8.0rc1}/src/snowflake/cli/api/project/schemas/snowpark/callable.py

@@ -19,9 +19,7 @@ from typing import Dict, List, Optional, Union
 from pydantic import Field, field_validator
 from snowflake.cli.api.project.schemas.identifier_model import ObjectIdentifierModel
 from snowflake.cli.api.project.schemas.snowpark.argument import Argument
-from snowflake.cli.api.project.schemas.updatable_model import (
-    UpdatableModel,
-)
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 
 
 class _CallableBase(UpdatableModel):