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

snowflake/cli/api/project/definition_manager.py

@@ -1,145 +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
-
-import functools
-import os
-from pathlib import Path
-from typing import List, Optional
-
-from snowflake.cli.api.project.definition import ProjectProperties, load_project
-from snowflake.cli.api.project.schemas.project_definition import (
-    ProjectDefinition,
-    ProjectDefinitionV1,
-)
-from snowflake.cli.api.utils.types import Context
-
-
-def _compat_is_mount(path: Path):
-    try:
-        return path.is_mount()
-    except NotImplementedError:
-        # If we can't figure out if path is mount then let's assume it is
-        # Windows support added in Python 3.12
-        return True
-
-
-class DefinitionManager:
-    BASE_DEFINITION_FILENAME = "snowflake.yml"
-    USER_DEFINITION_FILENAME = "snowflake.local.yml"
-
-    project_root: Path
-    _project_config_paths: List[Path]
-
-    def __init__(
-        self,
-        project_arg: Optional[str] = None,
-        context_overrides: Optional[Context] = None,
-    ) -> None:
-        project_root = Path(
-            os.path.abspath(project_arg) if project_arg else os.getcwd()
-        )
-
-        self.project_root = project_root
-        self._project_config_paths = self._find_definition_files(self.project_root)
-        self._context_overrides = context_overrides
-
-    @functools.cached_property
-    def has_definition_file(self):
-        return len(self._project_config_paths) > 0
-
-    @staticmethod
-    def _find_definition_files(project_root: Path) -> List[Path]:
-        base_config_file_path = DefinitionManager._base_definition_file_if_available(
-            project_root
-        )
-        user_config_file_path = DefinitionManager._user_definition_file_if_available(
-            project_root
-        )
-
-        definition_files: List[Path] = []
-        if base_config_file_path:
-            definition_files.append(base_config_file_path)
-            if user_config_file_path:
-                definition_files.append(user_config_file_path)
-
-        return definition_files
-
-    @staticmethod
-    def find_project_root(search_path: Path) -> Optional[Path]:
-        """
-        Recurse up the directory tree from the given search path until we find
-        a directory that contains a snowflake.yml file. We'll stop if we cross
-        a filesystem boundary or hit the user's HOME directory.
-        """
-        current_path = search_path
-        starting_mount = _compat_is_mount(search_path)
-        while current_path:
-            if (
-                _compat_is_mount(current_path) != starting_mount
-                or current_path.parent == current_path
-                or current_path == Path.home()
-            ):
-                return None
-
-            if (
-                DefinitionManager._base_definition_file_if_available(current_path)
-                is not None
-            ):
-                # found snowflake.yml, end the search here
-                return current_path
-
-            current_path = current_path.parent
-
-        return None
-
-    @staticmethod
-    def _definition_if_available(filename, project_path: Path) -> Optional[Path]:
-        file_path = Path(project_path) / filename
-        if file_path.is_file():
-            return file_path
-        return None
-
-    @staticmethod
-    def _base_definition_file_if_available(project_path: Path) -> Optional[Path]:
-        return DefinitionManager._definition_if_available(
-            DefinitionManager.BASE_DEFINITION_FILENAME, project_path
-        )
-
-    @staticmethod
-    def _user_definition_file_if_available(project_path: Path) -> Optional[Path]:
-        return DefinitionManager._definition_if_available(
-            DefinitionManager.USER_DEFINITION_FILENAME, project_path
-        )
-
-    @functools.cached_property
-    def _project_properties(self) -> ProjectProperties:
-        return load_project(self._project_config_paths, self._context_overrides)
-
-    @functools.cached_property
-    def _raw_project_data(self) -> ProjectProperties:
-        return load_project(self._project_config_paths, {}, False)
-
-    @functools.cached_property
-    def project_definition(self) -> ProjectDefinitionV1:
-        return self._project_properties.project_definition
-
-    @functools.cached_property
-    def unrendered_project_definition(self) -> ProjectDefinition:
-        return self._raw_project_data.project_definition
-
-    @functools.cached_property
-    def template_context(self) -> Context:
-        return self._project_properties.project_context

snowflake/cli/api/project/errors.py

@@ -1,56 +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 textwrap import dedent
-
-from click import ClickException
-from pydantic import ValidationError
-
-
-class SchemaValidationError(ClickException):
-    generic_message = "For field {location} you provided '{input}'. This caused: {msg}"
-    message_templates = {
-        "string_type": "{msg} for field '{location}', you provided '{input}'.",
-        "extra_forbidden": "{msg}. You provided field '{location}' with value '{input}' that is not supported in given version.",
-        "missing": "Your project definition is missing the following field: '{location}'",
-    }
-
-    def __init__(self, error: ValidationError):
-        errors = error.errors()
-        message = f"During evaluation of {error.title} in project definition following errors were encountered:\n"
-
-        def calculate_location(e):
-            if e["loc"] is None:
-                return None
-
-            # show numbers as list indexes and strings as dictionary keys. Example: key1[0].key2
-            result = "".join(
-                f"[{item}]" if isinstance(item, int) else f".{item}"
-                for item in e["loc"]
-            )
-
-            # remove leading dot from the string if any:
-            return result[1:] if result.startswith(".") else result
-
-        message += "\n".join(
-            [
-                self.message_templates.get(e["type"], self.generic_message).format(
-                    **e,
-                    location=calculate_location(e),
-                )
-                for e in errors
-            ]
-        )
-
-        super().__init__(dedent(message))

snowflake/cli/api/project/project_verification.py

@@ -1,23 +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 snowflake.cli.api.cli_global_context import get_cli_context
-from snowflake.cli.api.exceptions import NoProjectDefinitionError
-
-
-def assert_project_type(project_type: str):
-    cli_context = get_cli_context()
-    if not getattr(cli_context.project_definition, project_type, None):
-        raise NoProjectDefinitionError(
-            project_type=project_type, project_root=cli_context.project_root
-        )

snowflake/cli/api/project/schemas/__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/entities/__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/entities/common.py

@@ -1,153 +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 abc import ABC
-from typing import Dict, Generic, List, Optional, TypeVar, Union
-
-from pydantic import Field, PrivateAttr, field_validator
-from snowflake.cli.api.identifiers import FQN
-from snowflake.cli.api.project.schemas.updatable_model import (
-    IdentifierField,
-    UpdatableModel,
-)
-
-
-class SqlScriptHookType(UpdatableModel):
-    sql_script: str = Field(title="SQL file path relative to the project root")
-
-
-# Currently sql_script is the only supported hook type. Change to a Union once other hook types are added
-PostDeployHook = SqlScriptHookType
-
-
-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[PostDeployHook]] = Field(
-        title="Actions that will be executed after the application object is created/upgraded",
-        default=None,
-    )
-    use_mixins: Optional[List[str]] = Field(
-        title="Name of the mixin used to fill the entity fields",
-        default=None,
-    )
-
-    @field_validator("use_mixins", mode="before")
-    @classmethod
-    def ensure_use_mixins_is_a_list(
-        cls, mixins: Optional[str | List[str]]
-    ) -> Optional[List[str]]:
-        if isinstance(mixins, str):
-            return [mixins]
-        return mixins
-
-
-class Identifier(UpdatableModel):
-    name: str = Field(title="Entity name")
-    schema_: Optional[str] = Field(title="Entity schema", alias="schema", default=None)
-    database: Optional[str] = Field(title="Entity database", default=None)
-
-
-class EntityModelBase(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)
-    identifier: Optional[Union[Identifier | str]] = Field(
-        title="Entity identifier", default=None
-    )
-    # Set by parent model in post validation. To reference it use `entity_id`.
-    _entity_id: str = PrivateAttr(default=None)
-
-    @property
-    def entity_id(self):
-        return self._entity_id
-
-    def set_entity_id(self, value: str):
-        self._entity_id = value
-
-    def validate_identifier(self):
-        """Helper that's used by ProjectDefinition validator."""
-        if not self._entity_id and not self.identifier:
-            raise ValueError("Missing entity identifier")
-
-    @property
-    def fqn(self) -> FQN:
-        if isinstance(self.identifier, str):
-            return FQN.from_string(self.identifier)
-        if isinstance(self.identifier, Identifier):
-            return FQN.from_identifier_model_v2(self.identifier)
-        if self.entity_id:
-            return FQN.from_string(self.entity_id)
-
-
-TargetType = TypeVar("TargetType")
-
-
-class TargetField(UpdatableModel, Generic[TargetType]):
-    target: str = Field(
-        title="Reference to a target entity",
-    )
-
-    def get_type(self) -> type:
-        """
-        Returns the generic type of this class, indicating the entity type.
-        Pydantic extracts Generic annotations, and populates
-        them in __pydantic_generic_metadata__
-        """
-        return self.__pydantic_generic_metadata__["args"][0]
-
-
-class ImportsBaseModel:
-    imports: Optional[List[str]] = Field(
-        title="Stage and path to previously uploaded files you want to import",
-        default=[],
-    )
-
-    def get_imports_sql(self) -> str | None:
-        if not self.imports:
-            return None
-        imports = ", ".join(f"'{i}'" for i in self.imports)
-        return f"IMPORTS = ({imports})"
-
-
-class ExternalAccessBaseModel:
-    external_access_integrations: Optional[List[str]] = Field(
-        title="Names of external access integrations needed for this entity 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={},
-    )
-
-    def get_external_access_integrations_sql(self) -> str | None:
-        if not self.external_access_integrations:
-            return None
-        external_access_integration_name = ", ".join(self.external_access_integrations)
-        return f"external_access_integrations=({external_access_integration_name})"
-
-    def get_secrets_sql(self) -> str | None:
-        if not self.secrets:
-            return None
-        secrets = ", ".join(f"'{key}'={value}" for key, value in self.secrets.items())
-        return f"secrets=({secrets})"

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

@@ -1,61 +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, Union, get_args
-
-from snowflake.cli._plugins.nativeapp.entities.application import (
-    ApplicationEntity,
-    ApplicationEntityModel,
-)
-from snowflake.cli._plugins.nativeapp.entities.application_package import (
-    ApplicationPackageEntity,
-    ApplicationPackageEntityModel,
-)
-from snowflake.cli._plugins.snowpark.snowpark_entity import (
-    FunctionEntity,
-    ProcedureEntity,
-)
-from snowflake.cli._plugins.snowpark.snowpark_entity_model import (
-    FunctionEntityModel,
-    ProcedureEntityModel,
-)
-from snowflake.cli._plugins.streamlit.streamlit_entity import StreamlitEntity
-from snowflake.cli._plugins.streamlit.streamlit_entity_model import (
-    StreamlitEntityModel,
-)
-
-Entity = Union[
-    ApplicationEntity,
-    ApplicationPackageEntity,
-    StreamlitEntity,
-    ProcedureEntity,
-    FunctionEntity,
-]
-EntityModel = Union[
-    ApplicationEntityModel,
-    ApplicationPackageEntityModel,
-    StreamlitEntityModel,
-    FunctionEntityModel,
-    ProcedureEntityModel,
-]
-
-ALL_ENTITIES: List[Entity] = [*get_args(Entity)]
-ALL_ENTITY_MODELS: List[EntityModel] = [*get_args(EntityModel)]
-
-v2_entity_model_types_map = {e.get_type(): e for e in ALL_ENTITY_MODELS}
-v2_entity_model_to_entity_map: Dict[EntityModel, Entity] = {
-    e.get_entity_model_type(): e for e in ALL_ENTITIES
-}