snowflake-cli-labs 2.8.0rc1__py3-none-any.whl → 2.8.2__py3-none-any.whl

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

@@ -1,199 +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 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

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

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

@@ -1,28 +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
-
-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

@@ -1,69 +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 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

@@ -1,36 +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 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

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

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

@@ -1,46 +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 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

@@ -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,194 +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.
-
-        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)