snowflake-cli 2.8.2__py3-none-any.whl

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

@@ -0,0 +1,199 @@
+# 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 dataclasses import dataclass
+from typing import Dict, Optional, Union
+
+from packaging.version import Version
+from pydantic import Field, ValidationError, field_validator, model_validator
+from snowflake.cli.api.feature_flags import FeatureFlag
+from snowflake.cli.api.project.errors import SchemaValidationError
+from snowflake.cli.api.project.schemas.entities.application_entity import (
+    ApplicationEntity,
+)
+from snowflake.cli.api.project.schemas.entities.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,
+    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.types import Context
+from typing_extensions import Annotated
+
+
+@dataclass
+class ProjectProperties:
+    """
+    This class stores 2 objects representing the snowflake project:
+
+    The project_context object:
+    - Used as the context for templating when users reference variables in the project definition file.
+
+    The project_definition object:
+    - This is a transformed object type through Pydantic, which has been normalized.
+    - This object could have slightly different structure than what the users see in their yaml project definition files.
+    - This should be used for the business logic of snow CLI modules.
+    """
+
+    project_definition: ProjectDefinition
+    project_context: Context
+
+
+class _ProjectDefinitionBase(UpdatableModel):
+    def __init__(self, *args, **kwargs):
+        try:
+            super().__init__(**kwargs)
+        except ValidationError as e:
+            raise SchemaValidationError(e) from e
+
+    definition_version: Union[str, int] = Field(
+        title="Version of the project definition schema, which is currently 1",
+    )
+
+    @field_validator("definition_version")
+    @classmethod
+    def _is_supported_version(cls, version: str) -> str:
+        version = str(version)
+        version_map = get_version_map()
+        if version not in version_map:
+            raise ValueError(
+                f'Version {version} is not supported. Supported versions: {", ".join(version_map)}'
+            )
+        return version
+
+    def meets_version_requirement(self, required_version: str) -> bool:
+        return Version(self.definition_version) >= Version(required_version)
+
+
+class DefinitionV10(_ProjectDefinitionBase):
+    native_app: Optional[NativeApp] = Field(
+        title="Native app definitions for the project", default=None
+    )
+    snowpark: Optional[Snowpark] = Field(
+        title="Snowpark functions and procedures definitions for the project",
+        default=None,
+    )
+    streamlit: Optional[Streamlit] = Field(
+        title="Streamlit definitions for the project", default=None
+    )
+
+
+class DefinitionV11(DefinitionV10):
+    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,
+    )
+
+
+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_, 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
+
+    @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}")
+
+        # 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: Optional[Dict[str, Union[str, int, bool]]] = Field(
+        title="Default environment specification for this project.",
+        default=None,
+    )
+
+
+def build_project_definition(**data) -> ProjectDefinition:
+    """
+    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/snowpark/__init__.py

@@ -0,0 +1,13 @@
+# 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.

snowflake/cli/api/project/schemas/snowpark/argument.py

@@ -0,0 +1,28 @@
+# 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 Optional
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+
+
+class Argument(UpdatableModel):
+    name: str = Field(title="Name of the argument")
+    arg_type: str = Field(
+        title="Type of the argument", alias="type"
+    )  # TODO: consider introducing literal/enum here
+    default: Optional[str] = Field(title="Default value for an argument", default=None)

snowflake/cli/api/project/schemas/snowpark/callable.py

@@ -0,0 +1,69 @@
+# 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 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
+
+
+class _CallableBase(UpdatableModel):
+    handler: str = Field(
+        title="Function’s or procedure’s implementation of the object inside source module",
+        examples=["functions.hello_function"],
+    )
+    returns: str = Field(
+        title="Type of the result"
+    )  # TODO: again, consider Literal/Enum
+    signature: Union[str, List[Argument]] = Field(
+        title="The signature parameter describes consecutive arguments passed to the object"
+    )
+    runtime: Optional[Union[str, float]] = Field(
+        title="Python version to use when executing ", default=None
+    )
+    external_access_integrations: Optional[List[str]] = Field(
+        title="Names of external access integrations needed for this procedure’s handler code to access external networks",
+        default=[],
+    )
+    secrets: Optional[Dict[str, str]] = Field(
+        title="Assigns the names of secrets to variables so that you can use the variables to reference the secrets",
+        default={},
+    )
+    imports: Optional[List[str]] = Field(
+        title="Stage and path to previously uploaded files you want to import",
+        default=[],
+    )
+
+    @field_validator("runtime")
+    @classmethod
+    def convert_runtime(cls, runtime_input: Union[str, float]) -> str:
+        if isinstance(runtime_input, float):
+            return str(runtime_input)
+        return runtime_input
+
+
+class FunctionSchema(_CallableBase, ObjectIdentifierModel(object_name="function")):  # type: ignore
+    pass
+
+
+class ProcedureSchema(_CallableBase, ObjectIdentifierModel(object_name="procedure")):  # type: ignore
+    execute_as_caller: Optional[bool] = Field(
+        title="Determine whether the procedure is executed with the privileges of "
+        "the owner (you) or with the privileges of the caller",
+        default=False,
+    )

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

@@ -0,0 +1,36 @@
+# 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 List, Optional
+
+from pydantic import Field
+from snowflake.cli.api.project.schemas.snowpark.callable import (
+    FunctionSchema,
+    ProcedureSchema,
+)
+from snowflake.cli.api.project.schemas.updatable_model import UpdatableModel
+
+
+class Snowpark(UpdatableModel):
+    project_name: str = Field(title="Project identifier")
+    stage_name: str = Field(title="Stage in which project’s artifacts will be stored")
+    src: str = Field(title="Folder where your code should be located")
+    functions: Optional[List[FunctionSchema]] = Field(
+        title="List of functions defined in the project", default=[]
+    )
+    procedures: Optional[List[ProcedureSchema]] = Field(
+        title="List of procedures defined in the project", default=[]
+    )

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

@@ -0,0 +1,13 @@
+# 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.

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

@@ -0,0 +1,46 @@
+# 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 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
+
+
+class Streamlit(UpdatableModel, ObjectIdentifierModel(object_name="Streamlit")):  # type: ignore
+    stage: Optional[str] = Field(
+        title="Stage in which the app’s artifacts will be stored", default="streamlit"
+    )
+    query_warehouse: str = Field(
+        title="Snowflake warehouse to host the app", default="streamlit"
+    )
+    main_file: Optional[Path] = Field(
+        title="Entrypoint file of the Streamlit app", default="streamlit_app.py"
+    )
+    env_file: Optional[Path] = Field(
+        title="File defining additional configurations for the app, such as external dependencies",
+        default=None,
+    )
+    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,
+    )
+    title: Optional[str] = Field(
+        title="Human-readable title for the Streamlit dashboard", 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/api/project/schemas/updatable_model.py

@@ -0,0 +1,194 @@
+# 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 contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Iterator, Optional
+
+from pydantic import (
+    BaseModel,
+    ConfigDict,
+    Field,
+    ValidationInfo,
+    field_validator,
+)
+from pydantic.fields import FieldInfo
+from snowflake.cli.api.project.util import IDENTIFIER_NO_LENGTH
+
+PROJECT_TEMPLATE_START = "<%"
+
+
+def _is_templated(info: ValidationInfo, value: Any) -> bool:
+    return (
+        info.context
+        and info.context.get("skip_validation_on_templates", False)
+        and isinstance(value, str)
+        and PROJECT_TEMPLATE_START in value
+    )
+
+
+_initial_context: ContextVar[Optional[Dict[str, Any]]] = ContextVar(
+    "_init_context_var", default=None
+)
+
+
+@contextmanager
+def context(value: Dict[str, Any]) -> Iterator[None]:
+    """
+    Thread safe context for Pydantic.
+    By using `with context()`, you ensure context changes apply
+    to the with block only
+    """
+    token = _initial_context.set(value)
+    try:
+        yield
+    finally:
+        _initial_context.reset(token)
+
+
+class UpdatableModel(BaseModel):
+    model_config = ConfigDict(validate_assignment=True, extra="forbid")
+
+    def __init__(self, /, **data: Any) -> None:
+        """
+        Pydantic provides 2 options to pass in context:
+        1) Through `model_validate()` as a second argument.
+        2) Through a custom init method and the use of ContextVar
+
+        We decided not to use 1) because it silently stops working
+        if someone adds a pass through __init__ to any of the Pydantic models.
+
+        We decided to go with 2) as the safer approach.
+        Calling validate_python() in the __init__ is how we can pass context
+        on initialization according to Pydantic's documentation:
+        https://docs.pydantic.dev/latest/concepts/validators/#using-validation-context-with-basemodel-initialization
+        """
+        self.__pydantic_validator__.validate_python(
+            data,
+            self_instance=self,
+            context=_initial_context.get(),
+        )
+
+    @classmethod
+    def _is_entity_type_field(cls, field: Any) -> bool:
+        """
+        Checks if a field is of type `DiscriminatorField`
+        """
+        if not isinstance(field, FieldInfo) or not field.json_schema_extra:
+            return False
+
+        return (
+            "is_discriminator_field" in field.json_schema_extra
+            and field.json_schema_extra["is_discriminator_field"]
+        )
+
+    @classmethod
+    def __init_subclass__(cls, **kwargs):
+        """
+        This method will collect all the Pydantic annotations for the class
+        currently being initialized (any subclass of `UpdatableModel`).
+
+        It will add a field validator wrapper for every Pydantic field
+        in order to skip validation when templates are found.
+
+        It will apply this to all Pydantic fields, except for fields
+        marked as `DiscriminatorField`. These will be skipped because
+        Pydantic does not support validators for discriminator field types.
+        """
+
+        super().__init_subclass__(**kwargs)
+
+        field_annotations = {}
+        field_values = {}
+        # Go through the inheritance classes and collect all the annotations and
+        # all the values of the class attributes. We go in reverse order so that
+        # values in subclasses overrides values from parent classes in case of field overrides.
+
+        for class_ in reversed(cls.__mro__):
+            class_dict = class_.__dict__
+            field_annotations.update(class_dict.get("__annotations__", {}))
+
+            if "model_fields" in class_dict:
+                # This means the class dict has already been processed by Pydantic
+                # All fields should properly be populated in model_fields
+                field_values.update(class_dict["model_fields"])
+            else:
+                # If Pydantic did not process this class yet, get the values from class_dict directly
+                field_values.update(class_dict)
+
+        # Add Pydantic validation wrapper around all fields except `DiscriminatorField`s
+        for field_name in field_annotations:
+            if not cls._is_entity_type_field(field_values.get(field_name)):
+                cls._add_validator(field_name)
+
+    @classmethod
+    def _add_validator(cls, field_name: str):
+        """
+        Adds a Pydantic validator with mode=wrap for the provided `field_name`.
+        During validation, this will check if the field is templated (not expanded yet)
+        and in that case, it will skip all the remaining Pydantic validation on that field.
+
+        Since this validator is added last, it will skip all the other field validators
+        defined in the subclasses when templates are found.
+
+        This logic on templates only applies when context contains `skip_validation_on_templates` flag.
+        """
+
+        def validator_skipping_templated_str(cls, value, handler, info: ValidationInfo):
+            if _is_templated(info, value):
+                return value
+            return handler(value)
+
+        setattr(
+            cls,
+            f"_field_validator_with_verbose_name_to_avoid_name_conflict_{field_name}",
+            field_validator(field_name, mode="wrap")(validator_skipping_templated_str),
+        )
+
+    def update_from_dict(self, update_values: Dict[str, Any]):
+        """
+        Takes a dictionary with values to override.
+        If the field type is subclass of a UpdatableModel, its update_from_dict() method is called with
+        the value to be set.
+        If not, we use simple setattr to set new value.
+        Values provided are validated against original restrictions, so it's impossible to overwrite string field with
+        integer value etc.
+        """
+        for field, value in update_values.items():
+            if field in self.model_fields.keys():
+                if (
+                    hasattr(getattr(self, field), "update_from_dict")
+                    and field in self.model_fields_set
+                ):
+                    getattr(self, field).update_from_dict(value)
+                else:
+                    setattr(self, field, value)
+        return self
+
+
+def DiscriminatorField(*args, **kwargs):  # noqa N802
+    """
+    Use this type for discriminator fields used for differentiating
+    between different entity types.
+
+    When this `DiscriminatorField` is used on a pydantic attribute,
+    we will not allow templating on it.
+    """
+    return Field(is_discriminator_field=True, *args, **kwargs)
+
+
+def IdentifierField(*args, **kwargs):  # noqa N802
+    return Field(max_length=254, pattern=IDENTIFIER_NO_LENGTH, *args, **kwargs)