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

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

@@ -19,29 +19,29 @@ 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.project.errors import SchemaValidationError
-from snowflake.cli.api.project.schemas.entities.application_entity_model import (
+from snowflake.cli._plugins.nativeapp.application_entity_model import (
     ApplicationEntityModel,
 )
+from snowflake.cli.api.project.errors import SchemaValidationError
 from snowflake.cli.api.project.schemas.entities.common import (
-    DefaultsField,
     TargetField,
 )
 from snowflake.cli.api.project.schemas.entities.entities import (
     EntityModel,
     v2_entity_model_types_map,
 )
-from snowflake.cli.api.project.schemas.native_app.native_app import (
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.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.project.schemas.v1.snowpark.snowpark import Snowpark
+from snowflake.cli.api.project.schemas.v1.streamlit.streamlit import Streamlit
 from snowflake.cli.api.utils.types import Context
 from typing_extensions import Annotated
 
 AnnotatedEntity = Annotated[EntityModel, Field(discriminator="type")]
+scalar = str | int | float | bool
 
 
 @dataclass
@@ -62,6 +62,11 @@ class ProjectProperties:
     project_context: Context
 
 
+@dataclass
+class YamlOverride:
+    data: dict | list
+
+
 class _ProjectDefinitionBase(UpdatableModel):
     def __init__(self, *args, **kwargs):
         try:
@@ -114,31 +119,12 @@ class DefinitionV11(DefinitionV10):
 class DefinitionV20(_ProjectDefinitionBase):
     entities: Dict[str, AnnotatedEntity] = Field(title="Entity definitions.")
 
-    @model_validator(mode="before")
-    @classmethod
-    def apply_defaults(cls, data: Dict) -> Dict:
-        """
-        Applies default values that exist on the model but not specified in yml
-        """
-        if "defaults" in data and "entities" in data:
-            for key, entity in data["entities"].items():
-                entity_fields = get_allowed_fields_for_entity(entity)
-                if not entity_fields:
-                    continue
-                for default_key, default_value in data["defaults"].items():
-                    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_identifiers(
-        cls, entities: Dict[str, EntityModel]
-    ) -> Dict[str, EntityModel]:
-        for key, entity in entities.items():
+    @model_validator(mode="after")
+    def validate_entities_identifiers(self):
+        for key, entity in self.entities.items():
             entity.set_entity_id(key)
             entity.validate_identifier()
-        return entities
+        return self
 
     @field_validator("entities", mode="after")
     @classmethod
@@ -179,11 +165,6 @@ class DefinitionV20(_ProjectDefinitionBase):
                 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: Optional[Dict[str, Union[str, int, bool]]] = Field(
         title="Default environment specification for this project.",
         default=None,
@@ -203,22 +184,92 @@ class DefinitionV20(_ProjectDefinitionBase):
         if "mixins" not in data or "entities" not in data:
             return data
 
-        for entity in data["entities"].values():
+        entities = data["entities"]
+        for entity_name, entity in entities.items():
             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")
+            merged_values = cls._merge_mixins_with_entity(
+                entity_id=entity_name,
+                entity=entity,
+                entity_mixins_names=entity_mixins,
+                mixin_defs=data["mixins"],
+            )
+            entities[entity_name] = merged_values
+        return data
+
+    @classmethod
+    def _merge_mixins_with_entity(
+        cls,
+        entity_id: str,
+        entity: dict,
+        entity_mixins_names: list,
+        mixin_defs: dict,
+    ) -> dict:
+        # Validate mixins
+        for mixin_name in entity_mixins_names:
+            if mixin_name not in mixin_defs:
+                raise ValueError(f"Mixin {mixin_name} not defined")
+
+        # Build object override data from mixins
+        data: dict = {}
+        for mx_name in entity_mixins_names:
+            data = cls._merge_data(data, mixin_defs[mx_name])
+
+        for key, override_value in data.items():
+            if key not in get_allowed_fields_for_entity(entity):
+                raise ValueError(
+                    f"Unsupported key '{key}' for entity {entity_id} of type {entity['type']} "
+                )
+
+            entity_value = entity.get(key)
+            if (
+                entity_value is not None
+                and not isinstance(entity_value, YamlOverride)
+                and not isinstance(entity_value, type(override_value))
+            ):
+                raise ValueError(
+                    f"Value from mixins for property {key} is of type '{type(override_value).__name__}' "
+                    f"while entity {entity_id} expects value of type '{type(entity_value).__name__}'"
+                )
+
+        # Apply entity data on top of mixins
+        data = cls._merge_data(data, entity)
         return data
 
+    @classmethod
+    def _merge_data(
+        cls,
+        left: dict | list | scalar | None,
+        right: dict | list | scalar | None | YamlOverride,
+    ):
+        """
+        Merges right data into left. Right and left is expected to be of the same type, if not right is returned.
+        If left is sequence then missing elements from right are appended.
+        If left is dictionary then we update it with data from right. The update is done recursively key by key.
+        """
+        if isinstance(right, YamlOverride):
+            return right.data
+
+        if left is None:
+            return right
+
+        # At that point left and right are of the same type
+        if isinstance(left, dict) and isinstance(right, dict):
+            data = dict(left)
+            for key in right:
+                data[key] = cls._merge_data(left=data.get(key), right=right[key])
+            return data
+
+        if isinstance(left, list) and isinstance(right, list):
+            return _unique_extend(left, right)
+
+        if not isinstance(right, type(left)):
+            raise ValueError(f"Could not merge {type(right)} and {type(left)}.")
+
+        return right
+
     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}
 
@@ -263,8 +314,19 @@ 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 is None:
+        raise ValueError("Entity is missing type declaration.")
+
     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
+
+
+def _unique_extend(list_a: List, list_b: List) -> List:
+    new_list = list(list_a)
+    for item in list_b:
+        if item not in list_a:
+            new_list.append(item)
+    return new_list

snowflake/cli/api/project/schemas/{identifier_model.py → v1/identifier_model.py}

@@ -19,16 +19,9 @@ from typing import Optional, cast
 from pydantic import Field
 from snowflake.cli.api.project.schemas.updatable_model import (
     IdentifierField,
-    UpdatableModel,
 )
 
 
-class Identifier(UpdatableModel):
-    name: str = Field(title="Entity name")
-    schema_: str = Field(title="Entity schema", alias="schema", default=None)
-    database: str = Field(title="Entity database", default=None)
-
-
 class ObjectIdentifierBaseModel:
     """
     Type representing a base class defining object that can be identified by fully qualified name (db.schema.name).

snowflake/cli/api/project/schemas/{native_app → v1/native_app}/native_app.py

@@ -18,13 +18,13 @@ import re
 from typing import List, Optional, Union
 
 from pydantic import Field, field_validator
-from snowflake.cli.api.project.schemas.native_app.application import (
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.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.schemas.v1.native_app.package import Package, PackageV11
+from snowflake.cli.api.project.schemas.v1.native_app.path_mapping import PathMapping
 from snowflake.cli.api.project.util import (
     SCHEMA_AND_NAME,
 )

snowflake/cli/api/project/schemas/{snowpark → v1/snowpark}/callable.py

@@ -17,9 +17,9 @@ from __future__ import annotations
 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.v1.identifier_model import ObjectIdentifierModel
+from snowflake.cli.api.project.schemas.v1.snowpark.argument import Argument
 
 
 class _CallableBase(UpdatableModel):

snowflake/cli/api/project/schemas/{snowpark → v1/snowpark}/snowpark.py

@@ -17,11 +17,11 @@ from __future__ import annotations
 from typing import List, Optional
 
 from pydantic import Field
-from snowflake.cli.api.project.schemas.snowpark.callable import (
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.snowpark.callable import (
     FunctionSchema,
     ProcedureSchema,
 )
-from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
 
 
 class Snowpark(UpdatableModel):

snowflake/cli/api/project/schemas/{streamlit → v1/streamlit}/streamlit.py

@@ -18,8 +18,8 @@ from pathlib import Path
 from typing import List, Optional
 
 from pydantic import Field
-from snowflake.cli.api.project.schemas.identifier_model import ObjectIdentifierModel
 from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+from snowflake.cli.api.project.schemas.v1.identifier_model import ObjectIdentifierModel
 
 
 class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):  # type: ignore
@@ -44,3 +44,4 @@ class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):
     title: Optional[str] = Field(
         title="Human-readable title for the Streamlit dashboard", default=None
     )
+    comment: Optional[str] = Field(title="Comment for the Streamlit app", default=None)

snowflake/cli/api/rendering/project_definition_templates.py

@@ -24,6 +24,10 @@ _YML_TEMPLATE_START = "<%"
 _YML_TEMPLATE_END = "%>"
 
 
+def has_client_side_templates(template_content: str) -> bool:
+    return _YML_TEMPLATE_START in template_content
+
+
 def get_client_side_jinja_env() -> Environment:
     _random_block = "___very___unique___block___to___disable___logic___blocks___"
     return env_bootstrap(

snowflake/cli/api/rendering/sql_templates.py

@@ -55,6 +55,13 @@ def _does_template_have_env_syntax(env: Environment, template_content: str) -> b
     return bool(meta.find_undeclared_variables(template))
 
 
+def has_sql_templates(template_content: str) -> bool:
+    return (
+        _OLD_SQL_TEMPLATE_START in template_content
+        or _SQL_TEMPLATE_START in template_content
+    )
+
+
 def choose_sql_jinja_env_based_on_template_syntax(
     template_content: str, reference_name: Optional[str] = None
 ) -> Environment:

snowflake/cli/api/sql_execution.py

@@ -98,11 +98,7 @@ class SqlExecutor:
             )
 
     def current_role(self) -> str:
-        *_, cursor = self._execute_string(
-            "select current_role()", cursor_class=DictCursor
-        )
-        role_result = cursor.fetchone()
-        return role_result["CURRENT_ROLE()"]
+        return self._execute_query(f"select current_role()").fetchone()[0]
 
     @contextmanager
     def use_role(self, new_role: str):
@@ -110,10 +106,7 @@ class SqlExecutor:
         Switches to a different role for a while, then switches back.
         This is a no-op if the requested role is already active.
         """
-        role_result = self._execute_query(
-            f"select current_role()", cursor_class=DictCursor
-        ).fetchone()
-        prev_role = role_result["CURRENT_ROLE()"]
+        prev_role = self.current_role()
         is_different_role = new_role.lower() != prev_role.lower()
         if is_different_role:
             self._log.debug("Assuming different role: %s", new_role)
@@ -126,9 +119,9 @@ class SqlExecutor:
 
     def session_has_warehouse(self) -> bool:
         result = self._execute_query(
-            "select current_warehouse() is not null as result", cursor_class=DictCursor
+            "select current_warehouse() is not null"
         ).fetchone()
-        return bool(result.get("RESULT"))
+        return bool(result[0])
 
     @contextmanager
     def use_warehouse(self, new_wh: str):
@@ -138,12 +131,10 @@ class SqlExecutor:
         If there is no default warehouse in the account, it will throw an error.
         """
 
-        wh_result = self._execute_query(
-            f"select current_warehouse()", cursor_class=DictCursor
-        ).fetchone()
+        wh_result = self._execute_query(f"select current_warehouse()").fetchone()
         # If user has an assigned default warehouse, prev_wh will contain a value even if the warehouse is suspended.
         try:
-            prev_wh = wh_result["CURRENT_WAREHOUSE()"]
+            prev_wh = wh_result[0]
         except:
             prev_wh = None
 

snowflake/cli/api/utils/definition_rendering.py

@@ -277,7 +277,9 @@ def _add_defaults_to_definition(original_definition: Definition) -> Definition:
     with context({"skip_validation_on_templates": True}):
         # pass a flag to Pydantic to skip validation for templated scalars
         # populate the defaults
-        project_definition = build_project_definition(**original_definition)
+        project_definition = build_project_definition(
+            **copy.deepcopy(original_definition)
+        )
 
     definition_with_defaults = project_definition.model_dump(
         exclude_none=True, warnings=False, by_alias=True

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: snowflake-cli-labs
-Version: 3.0.0rc1
+Version: 3.0.0rc3
 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,14 +222,14 @@ Requires-Dist: jinja2==3.1.4
 Requires-Dist: packaging
 Requires-Dist: pip
 Requires-Dist: pluggy==1.5.0
-Requires-Dist: pydantic==2.8.2
-Requires-Dist: pyyaml==6.0.1
+Requires-Dist: pydantic==2.9.1
+Requires-Dist: pyyaml==6.0.2
 Requires-Dist: requests==2.32.3
 Requires-Dist: requirements-parser==0.11.0
-Requires-Dist: rich==13.7.1
-Requires-Dist: setuptools==74.1.0
-Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.1
-Requires-Dist: snowflake-core==0.8.0; python_version < '3.12'
+Requires-Dist: rich==13.8.1
+Requires-Dist: setuptools==75.1.0
+Requires-Dist: snowflake-connector-python[secure-local-storage]==3.12.2
+Requires-Dist: snowflake-core==0.12.1; python_version < '3.12'
 Requires-Dist: snowflake-snowpark-python>=1.15.0; python_version < '3.12'
 Requires-Dist: tomlkit==0.13.2
 Requires-Dist: typer==0.12.5
@@ -238,8 +238,8 @@ Provides-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.2; extra == 'development'
-Requires-Dist: syrupy==4.6.1; extra == 'development'
+Requires-Dist: pytest==8.3.3; extra == 'development'
+Requires-Dist: syrupy==4.7.1; extra == 'development'
 Description-Content-Type: text/markdown
 
 <!--