snowflake-cli-labs 3.0.0rc4__py3-none-any.whl → 3.0.1__py3-none-any.whl

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

@@ -1,330 +0,0 @@
-# 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 Any, Dict, List, Optional, Union
-
-from packaging.version import Version
-from pydantic import Field, ValidationError, field_validator, model_validator
-from snowflake.cli._plugins.nativeapp.entities.application import ApplicationEntityModel
-from snowflake.cli.api.project.errors import SchemaValidationError
-from snowflake.cli.api.project.schemas.entities.common import (
-    TargetField,
-)
-from snowflake.cli.api.project.schemas.entities.entities import (
-    EntityModel,
-    v2_entity_model_types_map,
-)
-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.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
-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
-
-
-@dataclass
-class YamlOverride:
-    data: dict | list
-
-
-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, AnnotatedEntity] = Field(title="Entity definitions.")
-
-    @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 self
-
-    @field_validator("entities", mode="after")
-    @classmethod
-    def validate_entities(
-        cls, entities: Dict[str, AnnotatedEntity]
-    ) -> Dict[str, AnnotatedEntity]:
-        for key, entity in entities.items():
-            # TODO Automatically detect TargetFields to validate
-            if isinstance(entity, list):
-                for e in entity:
-                    cls._validate_single_entity(e, entities)
-            else:
-                cls._validate_single_entity(entity, entities)
-        return entities
-
-    @classmethod
-    def _validate_single_entity(
-        cls, entity: EntityModel, entities: Dict[str, AnnotatedEntity]
-    ):
-        if entity.type == ApplicationEntityModel.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)
-
-    @classmethod
-    def _validate_target_field(
-        cls, target_key: str, target_type: EntityModel, entities: Dict[str, EntityModel]
-    ):
-        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__}"
-            )
-
-    env: Optional[Dict[str, Union[str, int, bool]]] = Field(
-        title="Default environment specification for this project.",
-        default=None,
-    )
-
-    mixins: Optional[Dict[str, Dict]] = Field(
-        title="Mixins to apply to entities",
-        default=None,
-    )
-
-    @model_validator(mode="before")
-    @classmethod
-    def apply_mixins(cls, data: Dict) -> Dict:
-        """
-        Applies mixins to those entities, whose meta field contains the mixin name.
-        """
-        if "mixins" not in data or "entities" not in data:
-            return data
-
-        entities = data["entities"]
-        for entity_name, entity in entities.items():
-            entity_mixins = entity_mixins_to_list(
-                entity.get("meta", {}).get("use_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}
-
-
-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, "2": DefinitionV20}
-    return version_map
-
-
-def entity_mixins_to_list(entity_mixins: Optional[str | List[str]]) -> List[str]:
-    """
-    Convert an optional string or a list of strings to a list of strings.
-    """
-    if entity_mixins is None:
-        return []
-    if isinstance(entity_mixins, str):
-        return [entity_mixins]
-    return entity_mixins
-
-
-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/template.py

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

@@ -1,202 +0,0 @@
-# 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.
-
-        private_attrs = set()
-        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)
-            for pa in class_dict.get("__private_attributes__", []):
-                private_attrs.add(pa)
-
-        # Add Pydantic validation wrapper around all fields except `DiscriminatorField`s
-        for field_name in field_annotations:
-            if field_name in private_attrs:
-                continue
-            field = field_values.get(field_name)
-            if not cls._is_entity_type_field(field):
-                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,
-            # Unique name so that subclasses get a unique instance of this validator
-            f"_{cls.__module__}.{cls.__name__}_validate_{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.
-    """
-    extra = dict(is_discriminator_field=True)
-    return Field(json_schema_extra=extra, *args, **kwargs)
-
-
-def IdentifierField(*args, **kwargs):  # noqa N802
-    return Field(max_length=254, pattern=IDENTIFIER_NO_LENGTH, *args, **kwargs)

snowflake/cli/api/project/schemas/v1/identifier_model.py

@@ -1,51 +0,0 @@
-# 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, cast
-
-from pydantic import Field
-from snowflake.cli.api.project.schemas.updatable_model import (
-    IdentifierField,
-)
-
-
-class ObjectIdentifierBaseModel:
-    """
-    Type representing a base class defining object that can be identified by fully qualified name (db.schema.name).
-    This is not a Pydantic model and the purpose of this class is to provide typing support to Pydantic models
-    generated using a factory class ObjectIdentifierModel.
-    """
-
-    name: str
-    database: Optional[str]
-    schema_name: Optional[str]
-
-
-def ObjectIdentifierModel(object_name: str) -> ObjectIdentifierBaseModel:  # noqa: N802
-    """Generates ObjectIdentifierBaseModel but with object specific descriptions."""
-
-    class _ObjectIdentifierModel(ObjectIdentifierBaseModel):
-        name: str = Field(title=f"{object_name.capitalize()} name")
-        database: Optional[str] = IdentifierField(
-            title=f"Name of the database for the {object_name}", default=None
-        )
-        schema_name: Optional[str] = IdentifierField(
-            title=f"Name of the schema for the {object_name}",
-            default=None,
-            alias="schema",
-        )
-
-    return cast(ObjectIdentifierBaseModel, _ObjectIdentifierModel)