snowflake-cli-labs 2.6.1__py3-none-any.whl → 2.7.0rc1__py3-none-any.whl

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

@@ -0,0 +1,85 @@
+# 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 __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 snowflake.cli.api.project.schemas.native_app.application import (
+    ApplicationPostDeployHook,
+)
+from snowflake.cli.api.project.schemas.updatable_model import (
+    IdentifierField,
+    UpdatableModel,
+)
+
+
+class MetaField(UpdatableModel):
+    warehouse: Optional[str] = IdentifierField(
+        title="Warehouse used to run the scripts", default=None
+    )
+    role: Optional[str] = IdentifierField(
+        title="Role to use when creating the entity object",
+        default=None,
+    )
+    post_deploy: Optional[List[ApplicationPostDeployHook]] = Field(
+        title="Actions that will be executed after the application object is created/upgraded",
+        default=None,
+    )
+
+
+class DefaultsField(UpdatableModel):
+    schema_: Optional[str] = Field(
+        title="Schema.",
+        validation_alias=AliasChoices("schema"),
+        default=None,
+    )
+    stage: Optional[str] = Field(
+        title="Stage.",
+        default=None,
+    )
+
+
+class EntityBase(ABC, UpdatableModel):
+    @classmethod
+    def get_type(cls) -> str:
+        return cls.model_fields["type"].annotation.__args__[0]
+
+    meta: Optional[MetaField] = Field(title="Meta fields", default=None)
+
+
+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)
+
+    @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
+        )

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

@@ -0,0 +1,30 @@
+# 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 __future__ import annotations
+
+from typing import Union, get_args
+
+from snowflake.cli.api.project.schemas.entities.application_entity import (
+    ApplicationEntity,
+)
+from snowflake.cli.api.project.schemas.entities.application_package_entity import (
+    ApplicationPackageEntity,
+)
+
+Entity = Union[ApplicationEntity, ApplicationPackageEntity]
+
+ALL_ENTITIES = [*get_args(Entity)]
+
+v2_entity_types_map = {e.get_type(): e for e in ALL_ENTITIES}

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

@@ -15,17 +15,30 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, Optional, Union
+from typing import Dict, Optional, Union
 
 from packaging.version import Version
-from pydantic import Field, ValidationError, field_validator
+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.common import (
+    DefaultsField,
+    TargetField,
+)
+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.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
 
 
 @dataclass
@@ -46,7 +59,7 @@ class ProjectProperties:
     project_context: Context
 
 
-class _BaseDefinition(UpdatableModel):
+class _ProjectDefinitionBase(UpdatableModel):
     def __init__(self, *args, **kwargs):
         try:
             super().__init__(**kwargs)
@@ -61,9 +74,10 @@ class _BaseDefinition(UpdatableModel):
     @classmethod
     def _is_supported_version(cls, version: str) -> str:
         version = str(version)
-        if version not in _version_map:
+        version_map = get_version_map()
+        if version not in version_map:
             raise ValueError(
-                f'Version {version} is not supported. Supported versions: {", ".join(_version_map)}'
+                f'Version {version} is not supported. Supported versions: {", ".join(version_map)}'
             )
         return version
 
@@ -71,7 +85,7 @@ class _BaseDefinition(UpdatableModel):
         return Version(self.definition_version) >= Version(required_version)
 
 
-class _DefinitionV10(_BaseDefinition):
+class DefinitionV10(_ProjectDefinitionBase):
     native_app: Optional[NativeApp] = Field(
         title="Native app definitions for the project", default=None
     )
@@ -84,7 +98,7 @@ class _DefinitionV10(_BaseDefinition):
     )
 
 
-class _DefinitionV11(_DefinitionV10):
+class DefinitionV11(DefinitionV10):
     env: Union[Dict[str, str], ProjectEnvironment, None] = Field(
         title="Environment specification for this project.",
         default=None,
@@ -102,23 +116,101 @@ class _DefinitionV11(_DefinitionV10):
         return ProjectEnvironment(default_env=(env or {}), override_env={})
 
 
-class ProjectDefinition(_DefinitionV11):
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        self._validate(kwargs)
+class DefinitionV20(_ProjectDefinitionBase):
+    entities: Dict[str, Annotated[Entity, Field(discriminator="type")]] = 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_type = entity["type"]
+                if entity_type not in v2_entity_types_map:
+                    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
+                    ):
+                        entity[default_key] = default_value
+        return data
+
+    @field_validator("entities", mode="after")
+    @classmethod
+    def validate_entities(cls, entities: Dict[str, Entity]) -> Dict[str, Entity]:
+        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]
+                    cls._validate_target_field(target_key, target_type, entities)
+        return entities
 
-    @staticmethod
-    def _validate(data: Any):
-        if not isinstance(data, dict):
-            return
-        if version := str(data.get("definition_version")):
-            version_model = _version_map.get(version)
-            if not version_model:
+    @classmethod
+    def _validate_target_field(
+        cls, target_key: str, target_type: Entity, entities: Dict[str, Entity]
+    ):
+        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"Unknown schema version: {version}. Supported version: {_supported_version}"
+                    f"Target type mismatch. Expected {target_type.__name__}, got {actual_target_type.__name__}"
                 )
-            version_model(**data)
 
+    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.",
+        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={})
 
-_version_map = {"1": _DefinitionV10, "1.1": _DefinitionV11}
-_supported_version = tuple(_version_map.keys())
+
+def build_project_definition(**data):
+    """
+    Returns a ProjectDefinition instance with a version matching the provided definition_version value
+    """
+    if not isinstance(data, dict):
+        return
+    version = data.get("definition_version")
+    version_model = get_version_map().get(str(version))
+    if not version or not version_model:
+        # Raises a SchemaValidationError
+        _ProjectDefinitionBase(**data)
+    return version_model(**data)
+
+
+ProjectDefinitionV1 = Union[DefinitionV10, DefinitionV11]
+ProjectDefinitionV2 = DefinitionV20
+ProjectDefinition = Union[ProjectDefinitionV1, ProjectDefinitionV2]
+
+
+def get_version_map():
+    version_map = {"1": DefinitionV10, "1.1": DefinitionV11}
+    if FeatureFlag.ENABLE_PROJECT_DEFINITION_V2.is_enabled():
+        version_map["2"] = DefinitionV20
+    return version_map

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

@@ -14,6 +14,7 @@
 
 from __future__ import annotations
 
+from pathlib import Path
 from typing import List, Optional
 
 from pydantic import Field
@@ -28,15 +29,15 @@ class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):
     query_warehouse: str = Field(
         title="Snowflake warehouse to host the app", default="streamlit"
     )
-    main_file: Optional[str] = Field(
+    main_file: Optional[Path] = Field(
         title="Entrypoint file of the Streamlit app", default="streamlit_app.py"
     )
-    env_file: Optional[str] = Field(
+    env_file: Optional[Path] = Field(
         title="File defining additional configurations for the app, such as external dependencies",
         default=None,
     )
-    pages_dir: Optional[str] = Field(title="Streamlit pages", default=None)
-    additional_source_files: Optional[List[str]] = Field(
+    pages_dir: Optional[Path] = Field(title="Streamlit pages", default=None)
+    additional_source_files: Optional[List[Path]] = Field(
         title="List of additional files which should be included into deployment artifacts",
         default=None,
     )

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

@@ -0,0 +1,77 @@
+# 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 __future__ import annotations
+
+from typing import Any, List, Literal, Optional, Union
+
+import typer
+from click import ClickException
+from pydantic import BaseModel, Field
+from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.secure_path import SecurePath
+
+
+class TemplateVariable(BaseModel):
+    name: str = Field(..., title="Variable identifier")
+    type: Optional[Literal["string", "float", "int"]] = Field(  # noqa: A003
+        title="Type of the variable", default=None
+    )
+    prompt: Optional[str] = Field(title="Prompt message for the variable", default=None)
+    default: Optional[Any] = Field(title="Default value of the variable", default=None)
+
+    @property
+    def python_type(self):
+        # override "unchecked type" (None) with 'str', as Typer deduces type from the value of 'default'
+        return {
+            "string": str,
+            "float": float,
+            "int": int,
+            None: str,
+        }[self.type]
+
+    def prompt_user_for_value(self, no_interactive: bool) -> Union[str, float, int]:
+        if no_interactive:
+            if not self.default:
+                raise ClickException(f"Cannot determine value of variable {self.name}")
+            return self.default
+
+        prompt = self.prompt if self.prompt else self.name
+        return typer.prompt(prompt, default=self.default, type=self.python_type)
+
+
+class Template(BaseModel):
+    minimum_cli_version: Optional[str] = Field(
+        None, title="Minimum version of Snowflake CLI supporting this template"
+    )
+    files_to_render: List[str] = Field(title="List of files to be rendered", default=[])
+    variables: List[TemplateVariable] = Field(
+        title="List of variables to be rendered", default=[]
+    )
+
+    def __init__(self, template_root: SecurePath, **kwargs):
+        super().__init__(**kwargs)
+        self._validate_files_exist(template_root)
+
+    def _validate_files_exist(self, template_root: SecurePath) -> None:
+        for path_in_template in self.files_to_render:
+            full_path = template_root / path_in_template
+            if not full_path.exists():
+                raise InvalidTemplate(
+                    f"[files_to_render] contains not-existing file: {path_in_template}"
+                )
+            if full_path.is_dir():
+                raise InvalidTemplate(
+                    f"[files_to_render] contains a dictionary: {path_in_template}"
+                )

snowflake/cli/{plugins/nativeapp/errno.py → api/rendering/__init__.py}

@@ -11,5 +11,3 @@
 # 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.
-
-APPLICATION_NO_LONGER_AVAILABLE = 93079

snowflake/cli/api/{utils/rendering.py → rendering/jinja.py}

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+
 from __future__ import annotations
 
 from pathlib import Path
@@ -19,14 +20,10 @@ from textwrap import dedent
 from typing import Dict, Optional
 
 import jinja2
-from click import ClickException
 from jinja2 import Environment, StrictUndefined, loaders
-from snowflake.cli.api.cli_global_context import cli_context
 from snowflake.cli.api.secure_path import UNLIMITED, SecurePath
 
 CONTEXT_KEY = "ctx"
-_YML_TEMPLATE_START = "<%"
-_YML_TEMPLATE_END = "%>"
 
 
 def read_file_content(file_name: str):
@@ -56,7 +53,7 @@ def procedure_from_js_file(env: jinja2.Environment, file_name: str):
 _CUSTOM_FILTERS = [read_file_content, procedure_from_js_file]
 
 
-def _env_bootstrap(env: Environment) -> Environment:
+def env_bootstrap(env: Environment) -> Environment:
     for custom_filter in _CUSTOM_FILTERS:
         env.filters[custom_filter.__name__] = custom_filter
 
@@ -84,36 +81,6 @@ class IgnoreAttrEnvironment(Environment):
             return self.undefined(obj=obj, name=argument)
 
 
-def get_snowflake_cli_jinja_env() -> Environment:
-    _random_block = "___very___unique___block___to___disable___logic___blocks___"
-    return _env_bootstrap(
-        IgnoreAttrEnvironment(
-            loader=loaders.BaseLoader(),
-            keep_trailing_newline=True,
-            variable_start_string=_YML_TEMPLATE_START,
-            variable_end_string=_YML_TEMPLATE_END,
-            block_start_string=_random_block,
-            block_end_string=_random_block,
-            undefined=StrictUndefined,
-        )
-    )
-
-
-def get_sql_cli_jinja_env():
-    _random_block = "___very___unique___block___to___disable___logic___blocks___"
-    return _env_bootstrap(
-        IgnoreAttrEnvironment(
-            loader=loaders.BaseLoader(),
-            keep_trailing_newline=True,
-            variable_start_string="&{",
-            variable_end_string="}",
-            block_start_string=_random_block,
-            block_end_string=_random_block,
-            undefined=StrictUndefined,
-        )
-    )
-
-
 def jinja_render_from_file(
     template_path: Path, data: Dict, output_file_path: Optional[Path] = None
 ) -> Optional[str]:
@@ -128,7 +95,7 @@ def jinja_render_from_file(
     Returns:
         None if file path is provided, else returns the rendered string.
     """
-    env = _env_bootstrap(
+    env = env_bootstrap(
         IgnoreAttrEnvironment(
             loader=loaders.FileSystemLoader(template_path.parent),
             keep_trailing_newline=True,
@@ -142,15 +109,3 @@ def jinja_render_from_file(
         return None
     else:
         return rendered_result
-
-
-def snowflake_sql_jinja_render(content: str, data: Dict | None = None) -> str:
-    data = data or {}
-    if CONTEXT_KEY in data:
-        raise ClickException(
-            f"{CONTEXT_KEY} in user defined data. The `{CONTEXT_KEY}` variable is reserved for CLI usage."
-        )
-
-    context_data = cli_context.template_context
-    context_data.update(data)
-    return get_sql_cli_jinja_env().from_string(content).render(**context_data)

snowflake/cli/api/rendering/project_definition_templates.py

@@ -0,0 +1,39 @@
+# 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 __future__ import annotations
+
+from jinja2 import Environment, StrictUndefined, loaders
+from snowflake.cli.api.rendering.jinja import (
+    IgnoreAttrEnvironment,
+    env_bootstrap,
+)
+
+_YML_TEMPLATE_START = "<%"
+_YML_TEMPLATE_END = "%>"
+
+
+def get_project_definition_cli_jinja_env() -> Environment:
+    _random_block = "___very___unique___block___to___disable___logic___blocks___"
+    return env_bootstrap(
+        IgnoreAttrEnvironment(
+            loader=loaders.BaseLoader(),
+            keep_trailing_newline=True,
+            variable_start_string=_YML_TEMPLATE_START,
+            variable_end_string=_YML_TEMPLATE_END,
+            block_start_string=_random_block,
+            block_end_string=_random_block,
+            undefined=StrictUndefined,
+        )
+    )

snowflake/cli/api/rendering/project_templates.py

@@ -0,0 +1,97 @@
+# 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 __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+from click import ClickException
+from jinja2 import (
+    Environment,
+    StrictUndefined,
+    TemplateSyntaxError,
+    UndefinedError,
+    loaders,
+)
+from snowflake.cli.api.exceptions import InvalidTemplate
+from snowflake.cli.api.rendering.jinja import IgnoreAttrEnvironment, env_bootstrap
+from snowflake.cli.api.secure_path import SecurePath
+
+_PROJECT_TEMPLATE_START = "<!"
+_PROJECT_TEMPLATE_END = "!>"
+
+
+def to_snowflake_identifier(value: Optional[str]) -> Optional[str]:
+    if not value:
+        # passing "None" through filter to allow jinja to handle "undefined value" exception
+        return value
+
+    import re
+
+    # TODO: remove code duplication when joining "init" with "snow app init"
+    # See https://docs.snowflake.com/en/sql-reference/identifiers-syntax for identifier syntax
+    unquoted_identifier_regex = r"([a-zA-Z_])([a-zA-Z0-9_$]{0,254})"
+    quoted_identifier_regex = r'"((""|[^"]){0,255})"'
+
+    if re.fullmatch(quoted_identifier_regex, value):
+        return value
+
+    result = re.sub(r"[. -]+", "_", value)
+    if not re.fullmatch(unquoted_identifier_regex, result):
+        raise ClickException(
+            f"Value '{value}' cannot be converted to valid Snowflake identifier."
+            ' Consider enclosing it in double quotes: ""'
+        )
+    return result
+
+
+PROJECT_TEMPLATE_FILTERS = [to_snowflake_identifier]
+
+
+def get_template_cli_jinja_env(template_root: SecurePath) -> Environment:
+    _random_block = "___very___unique___block___to___disable___logic___blocks___"
+    env = env_bootstrap(
+        IgnoreAttrEnvironment(
+            loader=loaders.FileSystemLoader(searchpath=template_root.path),
+            keep_trailing_newline=True,
+            variable_start_string=_PROJECT_TEMPLATE_START,
+            variable_end_string=_PROJECT_TEMPLATE_END,
+            block_start_string=_random_block,
+            block_end_string=_random_block,
+            undefined=StrictUndefined,
+        )
+    )
+    env.filters["to_snowflake_identifier"] = to_snowflake_identifier
+
+    return env
+
+
+def render_template_files(
+    template_root: SecurePath, files_to_render: List[str], data: Dict[str, Any]
+) -> None:
+    """Override all listed files with their rendered version."""
+    jinja_env = get_template_cli_jinja_env(template_root)
+    for path in files_to_render:
+        try:
+            jinja_template = jinja_env.get_template(path)
+            rendered_result = jinja_template.render(**data)
+            full_path = template_root / path
+            full_path.write_text(rendered_result)
+        except TemplateSyntaxError as err:
+            raise InvalidTemplate(
+                f"Invalid template syntax in line {err.lineno} of file {path}:\n"
+                f"{err.message}"
+            )
+        except UndefinedError as err:
+            raise InvalidTemplate(err.message)